diff --git a/.generator/src/generator/templates/model_enum.j2 b/.generator/src/generator/templates/model_enum.j2
index 9958bc500..5e2d17649 100644
--- a/.generator/src/generator/templates/model_enum.j2
+++ b/.generator/src/generator/templates/model_enum.j2
@@ -1,31 +1,20 @@
-{%- if model["type"] == "integer" %}
-use serde_repr::{Deserialize_repr, Serialize_repr};
-{%- else %}
-use serde::{Serialize, Deserialize};
-{%- endif %}
+{%- set dataType = model|simple_type(render_option=False) %}
+use serde::{Serialize, Deserialize, Serializer, Deserializer};
 {% if description is defined %}
 {{ description | block_comment }}
 {%- endif %}
 
 #[non_exhaustive]
-{%- if model["type"] == "integer" %}
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize_repr, Deserialize_repr)]
-#[repr({{model | simple_type(false, false)}})]
-{%- else %}
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
-{%- endif %}
-pub enum {{name}} {
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum {{ name }} {
 {%- for index, value in enumerate(model.enum) %}
-{%- if model["type"] == "integer" %}
-	{{ model["x-enum-varnames"][index] or value.upper() }} = {{value}},
-{%- else %}
-    #[serde(rename = "{{value}}")]
 	{{ model["x-enum-varnames"][index] or value.upper() }},
-{%- endif %}
 {%- endfor %}
 }
 
-impl ToString for {{name}} {
+{%- if not model["type"] == "integer" %}
+
+impl ToString for {{ name }} {
     fn to_string(&self) -> String {
         match self {
 {%- for index, value in enumerate(model.enum) %}
@@ -34,3 +23,41 @@ impl ToString for {{name}} {
         }
     }
 }
+{%- endif %}
+
+impl Serialize for {{ name }} {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+        {%- if model["type"] == "string"%}
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        {%- else %}
+            {%- for index, value in enumerate(model.enum) %}
+            Self::{{ model["x-enum-varnames"][index] or value.upper() }} => serializer.serialize_{{ dataType }}({{ value }}),
+            {%- endfor %}
+        {%- endif %}
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for {{ name }} {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: {{ dataType }} = {{ dataType }}::deserialize(deserializer)?;
+        Ok(match s{%- if model["type"] == "string" %}.as_str(){% endif %} {
+            {%- for index, value in enumerate(model.enum) %}
+            {%- if model["type"] == "string" %}"{%- endif %}{{ value }}{%- if model["type"] == "string" %}"{%- endif %} => Self::{{ model["x-enum-varnames"][index] or value.upper() }},
+            {%- endfor %}
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/Cargo.toml b/Cargo.toml
index c98f5c7e6..1e534ba81 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,7 +15,6 @@ reqwest = { version = "0.11.24", features = ["multipart"] }
 reqwest-middleware = "0.1.6"
 serde = { version = "1.0.197", features = ["derive"] }
 serde_json = "1.0.114"
-serde_repr = "0.1.17"
 serde_with = "3.6.1"
 url = "2.5.0"
 
diff --git a/LICENSE-3rdparty.csv b/LICENSE-3rdparty.csv
index b5da8a27e..23c18cbf6 100644
--- a/LICENSE-3rdparty.csv
+++ b/LICENSE-3rdparty.csv
@@ -84,7 +84,6 @@ schannel,https://github.com/steffengy/schannel-rs,MIT,"Steven Fackler <sfackler@
 security-framework,https://github.com/kornelski/rust-security-framework,MIT OR Apache-2.0,"Steven Fackler <sfackler@gmail.com>, Kornel <kornel@geekhood.net>"
 serde,https://github.com/serde-rs/serde,MIT OR Apache-2.0,"Erick Tryzelaar <erick.tryzelaar@gmail.com>, David Tolnay <dtolnay@gmail.com>"
 serde_json,https://github.com/serde-rs/json,MIT OR Apache-2.0,"Erick Tryzelaar <erick.tryzelaar@gmail.com>, David Tolnay <dtolnay@gmail.com>"
-serde_repr,https://github.com/dtolnay/serde-repr,MIT OR Apache-2.0,David Tolnay <dtolnay@gmail.com>
 serde_urlencoded,https://github.com/nox/serde_urlencoded,MIT OR Apache-2.0,Anthony Ramine <n.oxyde@gmail.com>
 serde_with,https://github.com/jonasbb/serde_with,MIT OR Apache-2.0,"Jonas Bushart, Marcin Kaźmierczak"
 serde_with_macros,https://github.com/jonasbb/serde_with,MIT OR Apache-2.0,Jonas Bushart
diff --git a/src/datadogV1/model/model_access_role.rs b/src/datadogV1/model/model_access_role.rs
index 19e8217f4..d958ef677 100644
--- a/src/datadogV1/model/model_access_role.rs
+++ b/src/datadogV1/model/model_access_role.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum AccessRole {
-    #[serde(rename = "st")]
     STANDARD,
-    #[serde(rename = "adm")]
     ADMIN,
-    #[serde(rename = "ro")]
     READ_ONLY,
-    #[serde(rename = "ERROR")]
     ERROR,
 }
 
@@ -27,3 +23,35 @@ impl ToString for AccessRole {
         }
     }
 }
+
+impl Serialize for AccessRole {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for AccessRole {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "st" => Self::STANDARD,
+            "adm" => Self::ADMIN,
+            "ro" => Self::READ_ONLY,
+            "ERROR" => Self::ERROR,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_alert_graph_widget_definition_type.rs b/src/datadogV1/model/model_alert_graph_widget_definition_type.rs
index 550c3206a..d72e01355 100644
--- a/src/datadogV1/model/model_alert_graph_widget_definition_type.rs
+++ b/src/datadogV1/model/model_alert_graph_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum AlertGraphWidgetDefinitionType {
-    #[serde(rename = "alert_graph")]
     ALERT_GRAPH,
 }
 
@@ -18,3 +17,32 @@ impl ToString for AlertGraphWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for AlertGraphWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for AlertGraphWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "alert_graph" => Self::ALERT_GRAPH,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_alert_value_widget_definition_type.rs b/src/datadogV1/model/model_alert_value_widget_definition_type.rs
index e7ba4943d..456171cb0 100644
--- a/src/datadogV1/model/model_alert_value_widget_definition_type.rs
+++ b/src/datadogV1/model/model_alert_value_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum AlertValueWidgetDefinitionType {
-    #[serde(rename = "alert_value")]
     ALERT_VALUE,
 }
 
@@ -18,3 +17,32 @@ impl ToString for AlertValueWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for AlertValueWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for AlertValueWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "alert_value" => Self::ALERT_VALUE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_apm_stats_query_row_type.rs b/src/datadogV1/model/model_apm_stats_query_row_type.rs
index bafc85b94..10b4d66d2 100644
--- a/src/datadogV1/model/model_apm_stats_query_row_type.rs
+++ b/src/datadogV1/model/model_apm_stats_query_row_type.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ApmStatsQueryRowType {
-    #[serde(rename = "service")]
     SERVICE,
-    #[serde(rename = "resource")]
     RESOURCE,
-    #[serde(rename = "span")]
     SPAN,
 }
 
@@ -24,3 +21,34 @@ impl ToString for ApmStatsQueryRowType {
         }
     }
 }
+
+impl Serialize for ApmStatsQueryRowType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ApmStatsQueryRowType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "service" => Self::SERVICE,
+            "resource" => Self::RESOURCE,
+            "span" => Self::SPAN,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_aws_event_bridge_create_status.rs b/src/datadogV1/model/model_aws_event_bridge_create_status.rs
index 90690376c..5db213791 100644
--- a/src/datadogV1/model/model_aws_event_bridge_create_status.rs
+++ b/src/datadogV1/model/model_aws_event_bridge_create_status.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum AWSEventBridgeCreateStatus {
-    #[serde(rename = "created")]
     CREATED,
 }
 
@@ -18,3 +17,32 @@ impl ToString for AWSEventBridgeCreateStatus {
         }
     }
 }
+
+impl Serialize for AWSEventBridgeCreateStatus {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for AWSEventBridgeCreateStatus {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "created" => Self::CREATED,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_aws_event_bridge_delete_status.rs b/src/datadogV1/model/model_aws_event_bridge_delete_status.rs
index 4068f6011..551eb217d 100644
--- a/src/datadogV1/model/model_aws_event_bridge_delete_status.rs
+++ b/src/datadogV1/model/model_aws_event_bridge_delete_status.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum AWSEventBridgeDeleteStatus {
-    #[serde(rename = "empty")]
     EMPTY,
 }
 
@@ -18,3 +17,32 @@ impl ToString for AWSEventBridgeDeleteStatus {
         }
     }
 }
+
+impl Serialize for AWSEventBridgeDeleteStatus {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for AWSEventBridgeDeleteStatus {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "empty" => Self::EMPTY,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_aws_namespace.rs b/src/datadogV1/model/model_aws_namespace.rs
index 870c3934f..7b746552f 100644
--- a/src/datadogV1/model/model_aws_namespace.rs
+++ b/src/datadogV1/model/model_aws_namespace.rs
@@ -2,24 +2,17 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum AWSNamespace {
-    #[serde(rename = "elb")]
     ELB,
-    #[serde(rename = "application_elb")]
     APPLICATION_ELB,
-    #[serde(rename = "sqs")]
     SQS,
-    #[serde(rename = "rds")]
     RDS,
-    #[serde(rename = "custom")]
     CUSTOM,
-    #[serde(rename = "network_elb")]
     NETWORK_ELB,
-    #[serde(rename = "lambda")]
     LAMBDA,
 }
 
@@ -36,3 +29,38 @@ impl ToString for AWSNamespace {
         }
     }
 }
+
+impl Serialize for AWSNamespace {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for AWSNamespace {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "elb" => Self::ELB,
+            "application_elb" => Self::APPLICATION_ELB,
+            "sqs" => Self::SQS,
+            "rds" => Self::RDS,
+            "custom" => Self::CUSTOM,
+            "network_elb" => Self::NETWORK_ELB,
+            "lambda" => Self::LAMBDA,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_change_widget_definition_type.rs b/src/datadogV1/model/model_change_widget_definition_type.rs
index b822577a5..cbde674d3 100644
--- a/src/datadogV1/model/model_change_widget_definition_type.rs
+++ b/src/datadogV1/model/model_change_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ChangeWidgetDefinitionType {
-    #[serde(rename = "change")]
     CHANGE,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ChangeWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for ChangeWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ChangeWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "change" => Self::CHANGE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_check_status_widget_definition_type.rs b/src/datadogV1/model/model_check_status_widget_definition_type.rs
index 65750946b..34ae51d1f 100644
--- a/src/datadogV1/model/model_check_status_widget_definition_type.rs
+++ b/src/datadogV1/model/model_check_status_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CheckStatusWidgetDefinitionType {
-    #[serde(rename = "check_status")]
     CHECK_STATUS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for CheckStatusWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for CheckStatusWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CheckStatusWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "check_status" => Self::CHECK_STATUS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_content_encoding.rs b/src/datadogV1/model/model_content_encoding.rs
index ee92ab7e6..37a2cc2c7 100644
--- a/src/datadogV1/model/model_content_encoding.rs
+++ b/src/datadogV1/model/model_content_encoding.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ContentEncoding {
-    #[serde(rename = "gzip")]
     GZIP,
-    #[serde(rename = "deflate")]
     DEFLATE,
 }
 
@@ -21,3 +19,33 @@ impl ToString for ContentEncoding {
         }
     }
 }
+
+impl Serialize for ContentEncoding {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ContentEncoding {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "gzip" => Self::GZIP,
+            "deflate" => Self::DEFLATE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_dashboard_global_time_live_span.rs b/src/datadogV1/model/model_dashboard_global_time_live_span.rs
index d248cc88a..6bf4ea2d8 100644
--- a/src/datadogV1/model/model_dashboard_global_time_live_span.rs
+++ b/src/datadogV1/model/model_dashboard_global_time_live_span.rs
@@ -2,26 +2,18 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum DashboardGlobalTimeLiveSpan {
-    #[serde(rename = "15m")]
     PAST_FIFTEEN_MINUTES,
-    #[serde(rename = "1h")]
     PAST_ONE_HOUR,
-    #[serde(rename = "4h")]
     PAST_FOUR_HOURS,
-    #[serde(rename = "1d")]
     PAST_ONE_DAY,
-    #[serde(rename = "2d")]
     PAST_TWO_DAYS,
-    #[serde(rename = "1w")]
     PAST_ONE_WEEK,
-    #[serde(rename = "1mo")]
     PAST_ONE_MONTH,
-    #[serde(rename = "3mo")]
     PAST_THREE_MONTHS,
 }
 
@@ -39,3 +31,39 @@ impl ToString for DashboardGlobalTimeLiveSpan {
         }
     }
 }
+
+impl Serialize for DashboardGlobalTimeLiveSpan {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for DashboardGlobalTimeLiveSpan {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "15m" => Self::PAST_FIFTEEN_MINUTES,
+            "1h" => Self::PAST_ONE_HOUR,
+            "4h" => Self::PAST_FOUR_HOURS,
+            "1d" => Self::PAST_ONE_DAY,
+            "2d" => Self::PAST_TWO_DAYS,
+            "1w" => Self::PAST_ONE_WEEK,
+            "1mo" => Self::PAST_ONE_MONTH,
+            "3mo" => Self::PAST_THREE_MONTHS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_dashboard_invite_type.rs b/src/datadogV1/model/model_dashboard_invite_type.rs
index 8a0e962e6..586fb3184 100644
--- a/src/datadogV1/model/model_dashboard_invite_type.rs
+++ b/src/datadogV1/model/model_dashboard_invite_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum DashboardInviteType {
-    #[serde(rename = "public_dashboard_invitation")]
     PUBLIC_DASHBOARD_INVITATION,
 }
 
@@ -18,3 +17,32 @@ impl ToString for DashboardInviteType {
         }
     }
 }
+
+impl Serialize for DashboardInviteType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for DashboardInviteType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "public_dashboard_invitation" => Self::PUBLIC_DASHBOARD_INVITATION,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_dashboard_layout_type.rs b/src/datadogV1/model/model_dashboard_layout_type.rs
index 6ebd2d979..35b58cbe8 100644
--- a/src/datadogV1/model/model_dashboard_layout_type.rs
+++ b/src/datadogV1/model/model_dashboard_layout_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum DashboardLayoutType {
-    #[serde(rename = "ordered")]
     ORDERED,
-    #[serde(rename = "free")]
     FREE,
 }
 
@@ -21,3 +19,33 @@ impl ToString for DashboardLayoutType {
         }
     }
 }
+
+impl Serialize for DashboardLayoutType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for DashboardLayoutType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "ordered" => Self::ORDERED,
+            "free" => Self::FREE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_dashboard_reflow_type.rs b/src/datadogV1/model/model_dashboard_reflow_type.rs
index f4c6b8537..bbd1cd202 100644
--- a/src/datadogV1/model/model_dashboard_reflow_type.rs
+++ b/src/datadogV1/model/model_dashboard_reflow_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum DashboardReflowType {
-    #[serde(rename = "auto")]
     AUTO,
-    #[serde(rename = "fixed")]
     FIXED,
 }
 
@@ -21,3 +19,33 @@ impl ToString for DashboardReflowType {
         }
     }
 }
+
+impl Serialize for DashboardReflowType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for DashboardReflowType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "auto" => Self::AUTO,
+            "fixed" => Self::FIXED,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_dashboard_resource_type.rs b/src/datadogV1/model/model_dashboard_resource_type.rs
index 20530c4ad..45a67e9cc 100644
--- a/src/datadogV1/model/model_dashboard_resource_type.rs
+++ b/src/datadogV1/model/model_dashboard_resource_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum DashboardResourceType {
-    #[serde(rename = "dashboard")]
     DASHBOARD,
 }
 
@@ -18,3 +17,32 @@ impl ToString for DashboardResourceType {
         }
     }
 }
+
+impl Serialize for DashboardResourceType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for DashboardResourceType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "dashboard" => Self::DASHBOARD,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_dashboard_share_type.rs b/src/datadogV1/model/model_dashboard_share_type.rs
index 299f6077d..f061dbadb 100644
--- a/src/datadogV1/model/model_dashboard_share_type.rs
+++ b/src/datadogV1/model/model_dashboard_share_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum DashboardShareType {
-    #[serde(rename = "open")]
     OPEN,
-    #[serde(rename = "invite")]
     INVITE,
 }
 
@@ -21,3 +19,33 @@ impl ToString for DashboardShareType {
         }
     }
 }
+
+impl Serialize for DashboardShareType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for DashboardShareType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "open" => Self::OPEN,
+            "invite" => Self::INVITE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_dashboard_type.rs b/src/datadogV1/model/model_dashboard_type.rs
index 635636023..319e59b96 100644
--- a/src/datadogV1/model/model_dashboard_type.rs
+++ b/src/datadogV1/model/model_dashboard_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum DashboardType {
-    #[serde(rename = "custom_timeboard")]
     CUSTOM_TIMEBOARD,
-    #[serde(rename = "custom_screenboard")]
     CUSTOM_SCREENBOARD,
 }
 
@@ -21,3 +19,33 @@ impl ToString for DashboardType {
         }
     }
 }
+
+impl Serialize for DashboardType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for DashboardType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "custom_timeboard" => Self::CUSTOM_TIMEBOARD,
+            "custom_screenboard" => Self::CUSTOM_SCREENBOARD,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_distribution_points_content_encoding.rs b/src/datadogV1/model/model_distribution_points_content_encoding.rs
index e3c2cd660..dedbdc2d9 100644
--- a/src/datadogV1/model/model_distribution_points_content_encoding.rs
+++ b/src/datadogV1/model/model_distribution_points_content_encoding.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum DistributionPointsContentEncoding {
-    #[serde(rename = "deflate")]
     DEFLATE,
 }
 
@@ -18,3 +17,32 @@ impl ToString for DistributionPointsContentEncoding {
         }
     }
 }
+
+impl Serialize for DistributionPointsContentEncoding {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for DistributionPointsContentEncoding {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "deflate" => Self::DEFLATE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_distribution_points_type.rs b/src/datadogV1/model/model_distribution_points_type.rs
index 2b0e497ef..8edca99df 100644
--- a/src/datadogV1/model/model_distribution_points_type.rs
+++ b/src/datadogV1/model/model_distribution_points_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum DistributionPointsType {
-    #[serde(rename = "distribution")]
     DISTRIBUTION,
 }
 
@@ -18,3 +17,32 @@ impl ToString for DistributionPointsType {
         }
     }
 }
+
+impl Serialize for DistributionPointsType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for DistributionPointsType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "distribution" => Self::DISTRIBUTION,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_distribution_widget_definition_type.rs b/src/datadogV1/model/model_distribution_widget_definition_type.rs
index 848916611..d97722345 100644
--- a/src/datadogV1/model/model_distribution_widget_definition_type.rs
+++ b/src/datadogV1/model/model_distribution_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum DistributionWidgetDefinitionType {
-    #[serde(rename = "distribution")]
     DISTRIBUTION,
 }
 
@@ -18,3 +17,32 @@ impl ToString for DistributionWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for DistributionWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for DistributionWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "distribution" => Self::DISTRIBUTION,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_distribution_widget_histogram_request_type.rs b/src/datadogV1/model/model_distribution_widget_histogram_request_type.rs
index 6785ed0c5..32ed9f2b3 100644
--- a/src/datadogV1/model/model_distribution_widget_histogram_request_type.rs
+++ b/src/datadogV1/model/model_distribution_widget_histogram_request_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum DistributionWidgetHistogramRequestType {
-    #[serde(rename = "histogram")]
     HISTOGRAM,
 }
 
@@ -18,3 +17,32 @@ impl ToString for DistributionWidgetHistogramRequestType {
         }
     }
 }
+
+impl Serialize for DistributionWidgetHistogramRequestType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for DistributionWidgetHistogramRequestType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "histogram" => Self::HISTOGRAM,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_event_alert_type.rs b/src/datadogV1/model/model_event_alert_type.rs
index 8550be7a0..e525e6f2b 100644
--- a/src/datadogV1/model/model_event_alert_type.rs
+++ b/src/datadogV1/model/model_event_alert_type.rs
@@ -2,24 +2,17 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum EventAlertType {
-    #[serde(rename = "error")]
     ERROR,
-    #[serde(rename = "warning")]
     WARNING,
-    #[serde(rename = "info")]
     INFO,
-    #[serde(rename = "success")]
     SUCCESS,
-    #[serde(rename = "user_update")]
     USER_UPDATE,
-    #[serde(rename = "recommendation")]
     RECOMMENDATION,
-    #[serde(rename = "snapshot")]
     SNAPSHOT,
 }
 
@@ -36,3 +29,38 @@ impl ToString for EventAlertType {
         }
     }
 }
+
+impl Serialize for EventAlertType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for EventAlertType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "error" => Self::ERROR,
+            "warning" => Self::WARNING,
+            "info" => Self::INFO,
+            "success" => Self::SUCCESS,
+            "user_update" => Self::USER_UPDATE,
+            "recommendation" => Self::RECOMMENDATION,
+            "snapshot" => Self::SNAPSHOT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_event_priority.rs b/src/datadogV1/model/model_event_priority.rs
index 30943219f..8d009c5b8 100644
--- a/src/datadogV1/model/model_event_priority.rs
+++ b/src/datadogV1/model/model_event_priority.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum EventPriority {
-    #[serde(rename = "normal")]
     NORMAL,
-    #[serde(rename = "low")]
     LOW,
 }
 
@@ -21,3 +19,33 @@ impl ToString for EventPriority {
         }
     }
 }
+
+impl Serialize for EventPriority {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for EventPriority {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "normal" => Self::NORMAL,
+            "low" => Self::LOW,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_event_stream_widget_definition_type.rs b/src/datadogV1/model/model_event_stream_widget_definition_type.rs
index c3567c3ce..24f543d8e 100644
--- a/src/datadogV1/model/model_event_stream_widget_definition_type.rs
+++ b/src/datadogV1/model/model_event_stream_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum EventStreamWidgetDefinitionType {
-    #[serde(rename = "event_stream")]
     EVENT_STREAM,
 }
 
@@ -18,3 +17,32 @@ impl ToString for EventStreamWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for EventStreamWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for EventStreamWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "event_stream" => Self::EVENT_STREAM,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_event_timeline_widget_definition_type.rs b/src/datadogV1/model/model_event_timeline_widget_definition_type.rs
index 3f8831b20..708a2d9b2 100644
--- a/src/datadogV1/model/model_event_timeline_widget_definition_type.rs
+++ b/src/datadogV1/model/model_event_timeline_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum EventTimelineWidgetDefinitionType {
-    #[serde(rename = "event_timeline")]
     EVENT_TIMELINE,
 }
 
@@ -18,3 +17,32 @@ impl ToString for EventTimelineWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for EventTimelineWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for EventTimelineWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "event_timeline" => Self::EVENT_TIMELINE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_formula_and_function_apm_dependency_stat_name.rs b/src/datadogV1/model/model_formula_and_function_apm_dependency_stat_name.rs
index bf7a434ca..2ea7dec67 100644
--- a/src/datadogV1/model/model_formula_and_function_apm_dependency_stat_name.rs
+++ b/src/datadogV1/model/model_formula_and_function_apm_dependency_stat_name.rs
@@ -2,24 +2,17 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FormulaAndFunctionApmDependencyStatName {
-    #[serde(rename = "avg_duration")]
     AVG_DURATION,
-    #[serde(rename = "avg_root_duration")]
     AVG_ROOT_DURATION,
-    #[serde(rename = "avg_spans_per_trace")]
     AVG_SPANS_PER_TRACE,
-    #[serde(rename = "error_rate")]
     ERROR_RATE,
-    #[serde(rename = "pct_exec_time")]
     PCT_EXEC_TIME,
-    #[serde(rename = "pct_of_traces")]
     PCT_OF_TRACES,
-    #[serde(rename = "total_traces_count")]
     TOTAL_TRACES_COUNT,
 }
 
@@ -36,3 +29,38 @@ impl ToString for FormulaAndFunctionApmDependencyStatName {
         }
     }
 }
+
+impl Serialize for FormulaAndFunctionApmDependencyStatName {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FormulaAndFunctionApmDependencyStatName {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "avg_duration" => Self::AVG_DURATION,
+            "avg_root_duration" => Self::AVG_ROOT_DURATION,
+            "avg_spans_per_trace" => Self::AVG_SPANS_PER_TRACE,
+            "error_rate" => Self::ERROR_RATE,
+            "pct_exec_time" => Self::PCT_EXEC_TIME,
+            "pct_of_traces" => Self::PCT_OF_TRACES,
+            "total_traces_count" => Self::TOTAL_TRACES_COUNT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_formula_and_function_apm_dependency_stats_data_source.rs b/src/datadogV1/model/model_formula_and_function_apm_dependency_stats_data_source.rs
index 1a4c74bdb..f7e8a9fab 100644
--- a/src/datadogV1/model/model_formula_and_function_apm_dependency_stats_data_source.rs
+++ b/src/datadogV1/model/model_formula_and_function_apm_dependency_stats_data_source.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FormulaAndFunctionApmDependencyStatsDataSource {
-    #[serde(rename = "apm_dependency_stats")]
     APM_DEPENDENCY_STATS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for FormulaAndFunctionApmDependencyStatsDataSource {
         }
     }
 }
+
+impl Serialize for FormulaAndFunctionApmDependencyStatsDataSource {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FormulaAndFunctionApmDependencyStatsDataSource {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "apm_dependency_stats" => Self::APM_DEPENDENCY_STATS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_formula_and_function_apm_resource_stat_name.rs b/src/datadogV1/model/model_formula_and_function_apm_resource_stat_name.rs
index 593ae98b6..04d683d29 100644
--- a/src/datadogV1/model/model_formula_and_function_apm_resource_stat_name.rs
+++ b/src/datadogV1/model/model_formula_and_function_apm_resource_stat_name.rs
@@ -2,32 +2,21 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FormulaAndFunctionApmResourceStatName {
-    #[serde(rename = "errors")]
     ERRORS,
-    #[serde(rename = "error_rate")]
     ERROR_RATE,
-    #[serde(rename = "hits")]
     HITS,
-    #[serde(rename = "latency_avg")]
     LATENCY_AVG,
-    #[serde(rename = "latency_distribution")]
     LATENCY_DISTRIBUTION,
-    #[serde(rename = "latency_max")]
     LATENCY_MAX,
-    #[serde(rename = "latency_p50")]
     LATENCY_P50,
-    #[serde(rename = "latency_p75")]
     LATENCY_P75,
-    #[serde(rename = "latency_p90")]
     LATENCY_P90,
-    #[serde(rename = "latency_p95")]
     LATENCY_P95,
-    #[serde(rename = "latency_p99")]
     LATENCY_P99,
 }
 
@@ -48,3 +37,42 @@ impl ToString for FormulaAndFunctionApmResourceStatName {
         }
     }
 }
+
+impl Serialize for FormulaAndFunctionApmResourceStatName {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FormulaAndFunctionApmResourceStatName {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "errors" => Self::ERRORS,
+            "error_rate" => Self::ERROR_RATE,
+            "hits" => Self::HITS,
+            "latency_avg" => Self::LATENCY_AVG,
+            "latency_distribution" => Self::LATENCY_DISTRIBUTION,
+            "latency_max" => Self::LATENCY_MAX,
+            "latency_p50" => Self::LATENCY_P50,
+            "latency_p75" => Self::LATENCY_P75,
+            "latency_p90" => Self::LATENCY_P90,
+            "latency_p95" => Self::LATENCY_P95,
+            "latency_p99" => Self::LATENCY_P99,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_formula_and_function_apm_resource_stats_data_source.rs b/src/datadogV1/model/model_formula_and_function_apm_resource_stats_data_source.rs
index cf6f04bce..fe7d0b211 100644
--- a/src/datadogV1/model/model_formula_and_function_apm_resource_stats_data_source.rs
+++ b/src/datadogV1/model/model_formula_and_function_apm_resource_stats_data_source.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FormulaAndFunctionApmResourceStatsDataSource {
-    #[serde(rename = "apm_resource_stats")]
     APM_RESOURCE_STATS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for FormulaAndFunctionApmResourceStatsDataSource {
         }
     }
 }
+
+impl Serialize for FormulaAndFunctionApmResourceStatsDataSource {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FormulaAndFunctionApmResourceStatsDataSource {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "apm_resource_stats" => Self::APM_RESOURCE_STATS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_formula_and_function_cloud_cost_data_source.rs b/src/datadogV1/model/model_formula_and_function_cloud_cost_data_source.rs
index 0ce35c453..d1c13cbd9 100644
--- a/src/datadogV1/model/model_formula_and_function_cloud_cost_data_source.rs
+++ b/src/datadogV1/model/model_formula_and_function_cloud_cost_data_source.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FormulaAndFunctionCloudCostDataSource {
-    #[serde(rename = "cloud_cost")]
     CLOUD_COST,
 }
 
@@ -18,3 +17,32 @@ impl ToString for FormulaAndFunctionCloudCostDataSource {
         }
     }
 }
+
+impl Serialize for FormulaAndFunctionCloudCostDataSource {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FormulaAndFunctionCloudCostDataSource {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "cloud_cost" => Self::CLOUD_COST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_formula_and_function_event_aggregation.rs b/src/datadogV1/model/model_formula_and_function_event_aggregation.rs
index 1dd829798..c4cef49e2 100644
--- a/src/datadogV1/model/model_formula_and_function_event_aggregation.rs
+++ b/src/datadogV1/model/model_formula_and_function_event_aggregation.rs
@@ -2,34 +2,22 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FormulaAndFunctionEventAggregation {
-    #[serde(rename = "count")]
     COUNT,
-    #[serde(rename = "cardinality")]
     CARDINALITY,
-    #[serde(rename = "median")]
     MEDIAN,
-    #[serde(rename = "pc75")]
     PC75,
-    #[serde(rename = "pc90")]
     PC90,
-    #[serde(rename = "pc95")]
     PC95,
-    #[serde(rename = "pc98")]
     PC98,
-    #[serde(rename = "pc99")]
     PC99,
-    #[serde(rename = "sum")]
     SUM,
-    #[serde(rename = "min")]
     MIN,
-    #[serde(rename = "max")]
     MAX,
-    #[serde(rename = "avg")]
     AVG,
 }
 
@@ -51,3 +39,43 @@ impl ToString for FormulaAndFunctionEventAggregation {
         }
     }
 }
+
+impl Serialize for FormulaAndFunctionEventAggregation {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FormulaAndFunctionEventAggregation {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "count" => Self::COUNT,
+            "cardinality" => Self::CARDINALITY,
+            "median" => Self::MEDIAN,
+            "pc75" => Self::PC75,
+            "pc90" => Self::PC90,
+            "pc95" => Self::PC95,
+            "pc98" => Self::PC98,
+            "pc99" => Self::PC99,
+            "sum" => Self::SUM,
+            "min" => Self::MIN,
+            "max" => Self::MAX,
+            "avg" => Self::AVG,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_formula_and_function_events_data_source.rs b/src/datadogV1/model/model_formula_and_function_events_data_source.rs
index c484d5782..8cb4d8cb4 100644
--- a/src/datadogV1/model/model_formula_and_function_events_data_source.rs
+++ b/src/datadogV1/model/model_formula_and_function_events_data_source.rs
@@ -2,30 +2,20 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FormulaAndFunctionEventsDataSource {
-    #[serde(rename = "logs")]
     LOGS,
-    #[serde(rename = "spans")]
     SPANS,
-    #[serde(rename = "network")]
     NETWORK,
-    #[serde(rename = "rum")]
     RUM,
-    #[serde(rename = "security_signals")]
     SECURITY_SIGNALS,
-    #[serde(rename = "profiles")]
     PROFILES,
-    #[serde(rename = "audit")]
     AUDIT,
-    #[serde(rename = "events")]
     EVENTS,
-    #[serde(rename = "ci_tests")]
     CI_TESTS,
-    #[serde(rename = "ci_pipelines")]
     CI_PIPELINES,
 }
 
@@ -45,3 +35,41 @@ impl ToString for FormulaAndFunctionEventsDataSource {
         }
     }
 }
+
+impl Serialize for FormulaAndFunctionEventsDataSource {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FormulaAndFunctionEventsDataSource {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "logs" => Self::LOGS,
+            "spans" => Self::SPANS,
+            "network" => Self::NETWORK,
+            "rum" => Self::RUM,
+            "security_signals" => Self::SECURITY_SIGNALS,
+            "profiles" => Self::PROFILES,
+            "audit" => Self::AUDIT,
+            "events" => Self::EVENTS,
+            "ci_tests" => Self::CI_TESTS,
+            "ci_pipelines" => Self::CI_PIPELINES,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_formula_and_function_metric_aggregation.rs b/src/datadogV1/model/model_formula_and_function_metric_aggregation.rs
index 3306b3039..53d452c64 100644
--- a/src/datadogV1/model/model_formula_and_function_metric_aggregation.rs
+++ b/src/datadogV1/model/model_formula_and_function_metric_aggregation.rs
@@ -2,26 +2,18 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FormulaAndFunctionMetricAggregation {
-    #[serde(rename = "avg")]
     AVG,
-    #[serde(rename = "min")]
     MIN,
-    #[serde(rename = "max")]
     MAX,
-    #[serde(rename = "sum")]
     SUM,
-    #[serde(rename = "last")]
     LAST,
-    #[serde(rename = "area")]
     AREA,
-    #[serde(rename = "l2norm")]
     L2NORM,
-    #[serde(rename = "percentile")]
     PERCENTILE,
 }
 
@@ -39,3 +31,39 @@ impl ToString for FormulaAndFunctionMetricAggregation {
         }
     }
 }
+
+impl Serialize for FormulaAndFunctionMetricAggregation {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FormulaAndFunctionMetricAggregation {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "avg" => Self::AVG,
+            "min" => Self::MIN,
+            "max" => Self::MAX,
+            "sum" => Self::SUM,
+            "last" => Self::LAST,
+            "area" => Self::AREA,
+            "l2norm" => Self::L2NORM,
+            "percentile" => Self::PERCENTILE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_formula_and_function_metric_data_source.rs b/src/datadogV1/model/model_formula_and_function_metric_data_source.rs
index 0fedefac5..ea36f92f1 100644
--- a/src/datadogV1/model/model_formula_and_function_metric_data_source.rs
+++ b/src/datadogV1/model/model_formula_and_function_metric_data_source.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FormulaAndFunctionMetricDataSource {
-    #[serde(rename = "metrics")]
     METRICS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for FormulaAndFunctionMetricDataSource {
         }
     }
 }
+
+impl Serialize for FormulaAndFunctionMetricDataSource {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FormulaAndFunctionMetricDataSource {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "metrics" => Self::METRICS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_formula_and_function_process_query_data_source.rs b/src/datadogV1/model/model_formula_and_function_process_query_data_source.rs
index 081f24b93..59bc1ba17 100644
--- a/src/datadogV1/model/model_formula_and_function_process_query_data_source.rs
+++ b/src/datadogV1/model/model_formula_and_function_process_query_data_source.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FormulaAndFunctionProcessQueryDataSource {
-    #[serde(rename = "process")]
     PROCESS,
-    #[serde(rename = "container")]
     CONTAINER,
 }
 
@@ -21,3 +19,33 @@ impl ToString for FormulaAndFunctionProcessQueryDataSource {
         }
     }
 }
+
+impl Serialize for FormulaAndFunctionProcessQueryDataSource {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FormulaAndFunctionProcessQueryDataSource {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "process" => Self::PROCESS,
+            "container" => Self::CONTAINER,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_formula_and_function_response_format.rs b/src/datadogV1/model/model_formula_and_function_response_format.rs
index 962a5b16c..edc05e830 100644
--- a/src/datadogV1/model/model_formula_and_function_response_format.rs
+++ b/src/datadogV1/model/model_formula_and_function_response_format.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FormulaAndFunctionResponseFormat {
-    #[serde(rename = "timeseries")]
     TIMESERIES,
-    #[serde(rename = "scalar")]
     SCALAR,
-    #[serde(rename = "event_list")]
     EVENT_LIST,
 }
 
@@ -24,3 +21,34 @@ impl ToString for FormulaAndFunctionResponseFormat {
         }
     }
 }
+
+impl Serialize for FormulaAndFunctionResponseFormat {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FormulaAndFunctionResponseFormat {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "timeseries" => Self::TIMESERIES,
+            "scalar" => Self::SCALAR,
+            "event_list" => Self::EVENT_LIST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_formula_and_function_slo_data_source.rs b/src/datadogV1/model/model_formula_and_function_slo_data_source.rs
index 2b5413e4b..aabcc90eb 100644
--- a/src/datadogV1/model/model_formula_and_function_slo_data_source.rs
+++ b/src/datadogV1/model/model_formula_and_function_slo_data_source.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FormulaAndFunctionSLODataSource {
-    #[serde(rename = "slo")]
     SLO,
 }
 
@@ -18,3 +17,32 @@ impl ToString for FormulaAndFunctionSLODataSource {
         }
     }
 }
+
+impl Serialize for FormulaAndFunctionSLODataSource {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FormulaAndFunctionSLODataSource {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "slo" => Self::SLO,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_formula_and_function_slo_group_mode.rs b/src/datadogV1/model/model_formula_and_function_slo_group_mode.rs
index bf22f4e7d..4922ae234 100644
--- a/src/datadogV1/model/model_formula_and_function_slo_group_mode.rs
+++ b/src/datadogV1/model/model_formula_and_function_slo_group_mode.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FormulaAndFunctionSLOGroupMode {
-    #[serde(rename = "overall")]
     OVERALL,
-    #[serde(rename = "components")]
     COMPONENTS,
 }
 
@@ -21,3 +19,33 @@ impl ToString for FormulaAndFunctionSLOGroupMode {
         }
     }
 }
+
+impl Serialize for FormulaAndFunctionSLOGroupMode {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FormulaAndFunctionSLOGroupMode {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "overall" => Self::OVERALL,
+            "components" => Self::COMPONENTS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_formula_and_function_slo_measure.rs b/src/datadogV1/model/model_formula_and_function_slo_measure.rs
index 7b9335ffb..0bfe2f70a 100644
--- a/src/datadogV1/model/model_formula_and_function_slo_measure.rs
+++ b/src/datadogV1/model/model_formula_and_function_slo_measure.rs
@@ -2,22 +2,16 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FormulaAndFunctionSLOMeasure {
-    #[serde(rename = "good_events")]
     GOOD_EVENTS,
-    #[serde(rename = "bad_events")]
     BAD_EVENTS,
-    #[serde(rename = "slo_status")]
     SLO_STATUS,
-    #[serde(rename = "error_budget_remaining")]
     ERROR_BUDGET_REMAINING,
-    #[serde(rename = "burn_rate")]
     BURN_RATE,
-    #[serde(rename = "error_budget_burndown")]
     ERROR_BUDGET_BURNDOWN,
 }
 
@@ -33,3 +27,37 @@ impl ToString for FormulaAndFunctionSLOMeasure {
         }
     }
 }
+
+impl Serialize for FormulaAndFunctionSLOMeasure {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FormulaAndFunctionSLOMeasure {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "good_events" => Self::GOOD_EVENTS,
+            "bad_events" => Self::BAD_EVENTS,
+            "slo_status" => Self::SLO_STATUS,
+            "error_budget_remaining" => Self::ERROR_BUDGET_REMAINING,
+            "burn_rate" => Self::BURN_RATE,
+            "error_budget_burndown" => Self::ERROR_BUDGET_BURNDOWN,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_formula_and_function_slo_query_type.rs b/src/datadogV1/model/model_formula_and_function_slo_query_type.rs
index 8c43eece4..344dc0eec 100644
--- a/src/datadogV1/model/model_formula_and_function_slo_query_type.rs
+++ b/src/datadogV1/model/model_formula_and_function_slo_query_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FormulaAndFunctionSLOQueryType {
-    #[serde(rename = "metric")]
     METRIC,
 }
 
@@ -18,3 +17,32 @@ impl ToString for FormulaAndFunctionSLOQueryType {
         }
     }
 }
+
+impl Serialize for FormulaAndFunctionSLOQueryType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FormulaAndFunctionSLOQueryType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "metric" => Self::METRIC,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_free_text_widget_definition_type.rs b/src/datadogV1/model/model_free_text_widget_definition_type.rs
index 547d78b03..c8c482d61 100644
--- a/src/datadogV1/model/model_free_text_widget_definition_type.rs
+++ b/src/datadogV1/model/model_free_text_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FreeTextWidgetDefinitionType {
-    #[serde(rename = "free_text")]
     FREE_TEXT,
 }
 
@@ -18,3 +17,32 @@ impl ToString for FreeTextWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for FreeTextWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FreeTextWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "free_text" => Self::FREE_TEXT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_funnel_request_type.rs b/src/datadogV1/model/model_funnel_request_type.rs
index 097f67fef..0513162af 100644
--- a/src/datadogV1/model/model_funnel_request_type.rs
+++ b/src/datadogV1/model/model_funnel_request_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FunnelRequestType {
-    #[serde(rename = "funnel")]
     FUNNEL,
 }
 
@@ -18,3 +17,32 @@ impl ToString for FunnelRequestType {
         }
     }
 }
+
+impl Serialize for FunnelRequestType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FunnelRequestType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "funnel" => Self::FUNNEL,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_funnel_source.rs b/src/datadogV1/model/model_funnel_source.rs
index 173f216c1..03371aaaa 100644
--- a/src/datadogV1/model/model_funnel_source.rs
+++ b/src/datadogV1/model/model_funnel_source.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FunnelSource {
-    #[serde(rename = "rum")]
     RUM,
 }
 
@@ -18,3 +17,32 @@ impl ToString for FunnelSource {
         }
     }
 }
+
+impl Serialize for FunnelSource {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FunnelSource {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "rum" => Self::RUM,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_funnel_widget_definition_type.rs b/src/datadogV1/model/model_funnel_widget_definition_type.rs
index 0bb84b3fe..32a62dd1d 100644
--- a/src/datadogV1/model/model_funnel_widget_definition_type.rs
+++ b/src/datadogV1/model/model_funnel_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FunnelWidgetDefinitionType {
-    #[serde(rename = "funnel")]
     FUNNEL,
 }
 
@@ -18,3 +17,32 @@ impl ToString for FunnelWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for FunnelWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FunnelWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "funnel" => Self::FUNNEL,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_geomap_widget_definition_type.rs b/src/datadogV1/model/model_geomap_widget_definition_type.rs
index 5ef175bd5..0ba4379a8 100644
--- a/src/datadogV1/model/model_geomap_widget_definition_type.rs
+++ b/src/datadogV1/model/model_geomap_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum GeomapWidgetDefinitionType {
-    #[serde(rename = "geomap")]
     GEOMAP,
 }
 
@@ -18,3 +17,32 @@ impl ToString for GeomapWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for GeomapWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for GeomapWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "geomap" => Self::GEOMAP,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_group_widget_definition_type.rs b/src/datadogV1/model/model_group_widget_definition_type.rs
index 6b656c129..f661cb6c8 100644
--- a/src/datadogV1/model/model_group_widget_definition_type.rs
+++ b/src/datadogV1/model/model_group_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum GroupWidgetDefinitionType {
-    #[serde(rename = "group")]
     GROUP,
 }
 
@@ -18,3 +17,32 @@ impl ToString for GroupWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for GroupWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for GroupWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "group" => Self::GROUP,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_heat_map_widget_definition_type.rs b/src/datadogV1/model/model_heat_map_widget_definition_type.rs
index 35372073e..e53e7b59b 100644
--- a/src/datadogV1/model/model_heat_map_widget_definition_type.rs
+++ b/src/datadogV1/model/model_heat_map_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum HeatMapWidgetDefinitionType {
-    #[serde(rename = "heatmap")]
     HEATMAP,
 }
 
@@ -18,3 +17,32 @@ impl ToString for HeatMapWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for HeatMapWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for HeatMapWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "heatmap" => Self::HEATMAP,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_host_map_widget_definition_type.rs b/src/datadogV1/model/model_host_map_widget_definition_type.rs
index cca04e1e4..f9765f8c1 100644
--- a/src/datadogV1/model/model_host_map_widget_definition_type.rs
+++ b/src/datadogV1/model/model_host_map_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum HostMapWidgetDefinitionType {
-    #[serde(rename = "hostmap")]
     HOSTMAP,
 }
 
@@ -18,3 +17,32 @@ impl ToString for HostMapWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for HostMapWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for HostMapWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "hostmap" => Self::HOSTMAP,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_hourly_usage_attribution_usage_type.rs b/src/datadogV1/model/model_hourly_usage_attribution_usage_type.rs
index 5c712d4b9..a343a4943 100644
--- a/src/datadogV1/model/model_hourly_usage_attribution_usage_type.rs
+++ b/src/datadogV1/model/model_hourly_usage_attribution_usage_type.rs
@@ -2,130 +2,70 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum HourlyUsageAttributionUsageType {
-    #[serde(rename = "api_usage")]
     API_USAGE,
-    #[serde(rename = "apm_fargate_usage")]
     APM_FARGATE_USAGE,
-    #[serde(rename = "apm_host_usage")]
     APM_HOST_USAGE,
-    #[serde(rename = "apm_usm_usage")]
     APM_USM_USAGE,
-    #[serde(rename = "appsec_fargate_usage")]
     APPSEC_FARGATE_USAGE,
-    #[serde(rename = "appsec_usage")]
     APPSEC_USAGE,
-    #[serde(rename = "browser_usage")]
     BROWSER_USAGE,
-    #[serde(rename = "ci_pipeline_indexed_spans_usage")]
     CI_PIPELINE_INDEXED_SPANS_USAGE,
-    #[serde(rename = "ci_test_indexed_spans_usage")]
     CI_TEST_INDEXED_SPANS_USAGE,
-    #[serde(rename = "ci_visibility_itr_usage")]
     CI_VISIBILITY_ITR_USAGE,
-    #[serde(rename = "cloud_siem_usage")]
     CLOUD_SIEM_USAGE,
-    #[serde(rename = "container_excl_agent_usage")]
     CONTAINER_EXCL_AGENT_USAGE,
-    #[serde(rename = "container_usage")]
     CONTAINER_USAGE,
-    #[serde(rename = "cspm_containers_usage")]
     CSPM_CONTAINERS_USAGE,
-    #[serde(rename = "cspm_hosts_usage")]
     CSPM_HOSTS_USAGE,
-    #[serde(rename = "custom_event_usage")]
     CUSTOM_EVENT_USAGE,
-    #[serde(rename = "custom_ingested_timeseries_usage")]
     CUSTOM_INGESTED_TIMESERIES_USAGE,
-    #[serde(rename = "custom_timeseries_usage")]
     CUSTOM_TIMESERIES_USAGE,
-    #[serde(rename = "cws_containers_usage")]
     CWS_CONTAINERS_USAGE,
-    #[serde(rename = "cws_hosts_usage")]
     CWS_HOSTS_USAGE,
-    #[serde(rename = "dbm_hosts_usage")]
     DBM_HOSTS_USAGE,
-    #[serde(rename = "dbm_queries_usage")]
     DBM_QUERIES_USAGE,
-    #[serde(rename = "estimated_indexed_logs_usage")]
     ESTIMATED_INDEXED_LOGS_USAGE,
-    #[serde(rename = "estimated_indexed_spans_usage")]
     ESTIMATED_INDEXED_SPANS_USAGE,
-    #[serde(rename = "estimated_ingested_logs_usage")]
     ESTIMATED_INGESTED_LOGS_USAGE,
-    #[serde(rename = "estimated_ingested_spans_usage")]
     ESTIMATED_INGESTED_SPANS_USAGE,
-    #[serde(rename = "estimated_rum_sessions_usage")]
     ESTIMATED_RUM_SESSIONS_USAGE,
-    #[serde(rename = "fargate_usage")]
     FARGATE_USAGE,
-    #[serde(rename = "functions_usage")]
     FUNCTIONS_USAGE,
-    #[serde(rename = "indexed_spans_usage")]
     INDEXED_SPANS_USAGE,
-    #[serde(rename = "infra_host_usage")]
     INFRA_HOST_USAGE,
-    #[serde(rename = "ingested_logs_bytes_usage")]
     INGESTED_LOGS_BYTES_USAGE,
-    #[serde(rename = "ingested_spans_bytes_usage")]
     INGESTED_SPANS_BYTES_USAGE,
-    #[serde(rename = "invocations_usage")]
     INVOCATIONS_USAGE,
-    #[serde(rename = "lambda_traced_invocations_usage")]
     LAMBDA_TRACED_INVOCATIONS_USAGE,
-    #[serde(rename = "logs_indexed_15day_usage")]
     LOGS_INDEXED_15DAY_USAGE,
-    #[serde(rename = "logs_indexed_180day_usage")]
     LOGS_INDEXED_180DAY_USAGE,
-    #[serde(rename = "logs_indexed_30day_usage")]
     LOGS_INDEXED_30DAY_USAGE,
-    #[serde(rename = "logs_indexed_360day_usage")]
     LOGS_INDEXED_360DAY_USAGE,
-    #[serde(rename = "logs_indexed_3day_usage")]
     LOGS_INDEXED_3DAY_USAGE,
-    #[serde(rename = "logs_indexed_45day_usage")]
     LOGS_INDEXED_45DAY_USAGE,
-    #[serde(rename = "logs_indexed_60day_usage")]
     LOGS_INDEXED_60DAY_USAGE,
-    #[serde(rename = "logs_indexed_7day_usage")]
     LOGS_INDEXED_7DAY_USAGE,
-    #[serde(rename = "logs_indexed_90day_usage")]
     LOGS_INDEXED_90DAY_USAGE,
-    #[serde(rename = "logs_indexed_custom_retention_usage")]
     LOGS_INDEXED_CUSTOM_RETENTION_USAGE,
-    #[serde(rename = "mobile_app_testing_usage")]
     MOBILE_APP_TESTING_USAGE,
-    #[serde(rename = "ndm_netflow_usage")]
     NDM_NETFLOW_USAGE,
-    #[serde(rename = "npm_host_usage")]
     NPM_HOST_USAGE,
-    #[serde(rename = "obs_pipeline_bytes_usage")]
     OBS_PIPELINE_BYTES_USAGE,
-    #[serde(rename = "profiled_container_usage")]
     PROFILED_CONTAINER_USAGE,
-    #[serde(rename = "profiled_fargate_usage")]
     PROFILED_FARGATE_USAGE,
-    #[serde(rename = "profiled_host_usage")]
     PROFILED_HOST_USAGE,
-    #[serde(rename = "rum_browser_mobile_sessions_usage")]
     RUM_BROWSER_MOBILE_SESSIONS_USAGE,
-    #[serde(rename = "rum_replay_sessions_usage")]
     RUM_REPLAY_SESSIONS_USAGE,
-    #[serde(rename = "sds_scanned_bytes_usage")]
     SDS_SCANNED_BYTES_USAGE,
-    #[serde(rename = "serverless_apps_usage")]
     SERVERLESS_APPS_USAGE,
-    #[serde(rename = "siem_ingested_bytes_usage")]
     SIEM_INGESTED_BYTES_USAGE,
-    #[serde(rename = "snmp_usage")]
     SNMP_USAGE,
-    #[serde(rename = "universal_service_monitoring_usage")]
     UNIVERSAL_SERVICE_MONITORING_USAGE,
-    #[serde(rename = "vuln_management_hosts_usage")]
     VULN_MANAGEMENT_HOSTS_USAGE,
 }
 
@@ -207,3 +147,91 @@ impl ToString for HourlyUsageAttributionUsageType {
         }
     }
 }
+
+impl Serialize for HourlyUsageAttributionUsageType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for HourlyUsageAttributionUsageType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "api_usage" => Self::API_USAGE,
+            "apm_fargate_usage" => Self::APM_FARGATE_USAGE,
+            "apm_host_usage" => Self::APM_HOST_USAGE,
+            "apm_usm_usage" => Self::APM_USM_USAGE,
+            "appsec_fargate_usage" => Self::APPSEC_FARGATE_USAGE,
+            "appsec_usage" => Self::APPSEC_USAGE,
+            "browser_usage" => Self::BROWSER_USAGE,
+            "ci_pipeline_indexed_spans_usage" => Self::CI_PIPELINE_INDEXED_SPANS_USAGE,
+            "ci_test_indexed_spans_usage" => Self::CI_TEST_INDEXED_SPANS_USAGE,
+            "ci_visibility_itr_usage" => Self::CI_VISIBILITY_ITR_USAGE,
+            "cloud_siem_usage" => Self::CLOUD_SIEM_USAGE,
+            "container_excl_agent_usage" => Self::CONTAINER_EXCL_AGENT_USAGE,
+            "container_usage" => Self::CONTAINER_USAGE,
+            "cspm_containers_usage" => Self::CSPM_CONTAINERS_USAGE,
+            "cspm_hosts_usage" => Self::CSPM_HOSTS_USAGE,
+            "custom_event_usage" => Self::CUSTOM_EVENT_USAGE,
+            "custom_ingested_timeseries_usage" => Self::CUSTOM_INGESTED_TIMESERIES_USAGE,
+            "custom_timeseries_usage" => Self::CUSTOM_TIMESERIES_USAGE,
+            "cws_containers_usage" => Self::CWS_CONTAINERS_USAGE,
+            "cws_hosts_usage" => Self::CWS_HOSTS_USAGE,
+            "dbm_hosts_usage" => Self::DBM_HOSTS_USAGE,
+            "dbm_queries_usage" => Self::DBM_QUERIES_USAGE,
+            "estimated_indexed_logs_usage" => Self::ESTIMATED_INDEXED_LOGS_USAGE,
+            "estimated_indexed_spans_usage" => Self::ESTIMATED_INDEXED_SPANS_USAGE,
+            "estimated_ingested_logs_usage" => Self::ESTIMATED_INGESTED_LOGS_USAGE,
+            "estimated_ingested_spans_usage" => Self::ESTIMATED_INGESTED_SPANS_USAGE,
+            "estimated_rum_sessions_usage" => Self::ESTIMATED_RUM_SESSIONS_USAGE,
+            "fargate_usage" => Self::FARGATE_USAGE,
+            "functions_usage" => Self::FUNCTIONS_USAGE,
+            "indexed_spans_usage" => Self::INDEXED_SPANS_USAGE,
+            "infra_host_usage" => Self::INFRA_HOST_USAGE,
+            "ingested_logs_bytes_usage" => Self::INGESTED_LOGS_BYTES_USAGE,
+            "ingested_spans_bytes_usage" => Self::INGESTED_SPANS_BYTES_USAGE,
+            "invocations_usage" => Self::INVOCATIONS_USAGE,
+            "lambda_traced_invocations_usage" => Self::LAMBDA_TRACED_INVOCATIONS_USAGE,
+            "logs_indexed_15day_usage" => Self::LOGS_INDEXED_15DAY_USAGE,
+            "logs_indexed_180day_usage" => Self::LOGS_INDEXED_180DAY_USAGE,
+            "logs_indexed_30day_usage" => Self::LOGS_INDEXED_30DAY_USAGE,
+            "logs_indexed_360day_usage" => Self::LOGS_INDEXED_360DAY_USAGE,
+            "logs_indexed_3day_usage" => Self::LOGS_INDEXED_3DAY_USAGE,
+            "logs_indexed_45day_usage" => Self::LOGS_INDEXED_45DAY_USAGE,
+            "logs_indexed_60day_usage" => Self::LOGS_INDEXED_60DAY_USAGE,
+            "logs_indexed_7day_usage" => Self::LOGS_INDEXED_7DAY_USAGE,
+            "logs_indexed_90day_usage" => Self::LOGS_INDEXED_90DAY_USAGE,
+            "logs_indexed_custom_retention_usage" => Self::LOGS_INDEXED_CUSTOM_RETENTION_USAGE,
+            "mobile_app_testing_usage" => Self::MOBILE_APP_TESTING_USAGE,
+            "ndm_netflow_usage" => Self::NDM_NETFLOW_USAGE,
+            "npm_host_usage" => Self::NPM_HOST_USAGE,
+            "obs_pipeline_bytes_usage" => Self::OBS_PIPELINE_BYTES_USAGE,
+            "profiled_container_usage" => Self::PROFILED_CONTAINER_USAGE,
+            "profiled_fargate_usage" => Self::PROFILED_FARGATE_USAGE,
+            "profiled_host_usage" => Self::PROFILED_HOST_USAGE,
+            "rum_browser_mobile_sessions_usage" => Self::RUM_BROWSER_MOBILE_SESSIONS_USAGE,
+            "rum_replay_sessions_usage" => Self::RUM_REPLAY_SESSIONS_USAGE,
+            "sds_scanned_bytes_usage" => Self::SDS_SCANNED_BYTES_USAGE,
+            "serverless_apps_usage" => Self::SERVERLESS_APPS_USAGE,
+            "siem_ingested_bytes_usage" => Self::SIEM_INGESTED_BYTES_USAGE,
+            "snmp_usage" => Self::SNMP_USAGE,
+            "universal_service_monitoring_usage" => Self::UNIVERSAL_SERVICE_MONITORING_USAGE,
+            "vuln_management_hosts_usage" => Self::VULN_MANAGEMENT_HOSTS_USAGE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_i_frame_widget_definition_type.rs b/src/datadogV1/model/model_i_frame_widget_definition_type.rs
index bff9aed0a..60420a075 100644
--- a/src/datadogV1/model/model_i_frame_widget_definition_type.rs
+++ b/src/datadogV1/model/model_i_frame_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IFrameWidgetDefinitionType {
-    #[serde(rename = "iframe")]
     IFRAME,
 }
 
@@ -18,3 +17,32 @@ impl ToString for IFrameWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for IFrameWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IFrameWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "iframe" => Self::IFRAME,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_image_widget_definition_type.rs b/src/datadogV1/model/model_image_widget_definition_type.rs
index 5e62209fd..1125ef836 100644
--- a/src/datadogV1/model/model_image_widget_definition_type.rs
+++ b/src/datadogV1/model/model_image_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ImageWidgetDefinitionType {
-    #[serde(rename = "image")]
     IMAGE,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ImageWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for ImageWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ImageWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "image" => Self::IMAGE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_list_stream_column_width.rs b/src/datadogV1/model/model_list_stream_column_width.rs
index 66ca14960..d8d1961f7 100644
--- a/src/datadogV1/model/model_list_stream_column_width.rs
+++ b/src/datadogV1/model/model_list_stream_column_width.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ListStreamColumnWidth {
-    #[serde(rename = "auto")]
     AUTO,
-    #[serde(rename = "compact")]
     COMPACT,
-    #[serde(rename = "full")]
     FULL,
 }
 
@@ -24,3 +21,34 @@ impl ToString for ListStreamColumnWidth {
         }
     }
 }
+
+impl Serialize for ListStreamColumnWidth {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ListStreamColumnWidth {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "auto" => Self::AUTO,
+            "compact" => Self::COMPACT,
+            "full" => Self::FULL,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_list_stream_compute_aggregation.rs b/src/datadogV1/model/model_list_stream_compute_aggregation.rs
index 009345e77..18c7a4fc2 100644
--- a/src/datadogV1/model/model_list_stream_compute_aggregation.rs
+++ b/src/datadogV1/model/model_list_stream_compute_aggregation.rs
@@ -2,40 +2,25 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ListStreamComputeAggregation {
-    #[serde(rename = "count")]
     COUNT,
-    #[serde(rename = "cardinality")]
     CARDINALITY,
-    #[serde(rename = "median")]
     MEDIAN,
-    #[serde(rename = "pc75")]
     PC75,
-    #[serde(rename = "pc90")]
     PC90,
-    #[serde(rename = "pc95")]
     PC95,
-    #[serde(rename = "pc98")]
     PC98,
-    #[serde(rename = "pc99")]
     PC99,
-    #[serde(rename = "sum")]
     SUM,
-    #[serde(rename = "min")]
     MIN,
-    #[serde(rename = "max")]
     MAX,
-    #[serde(rename = "avg")]
     AVG,
-    #[serde(rename = "earliest")]
     EARLIEST,
-    #[serde(rename = "latest")]
     LATEST,
-    #[serde(rename = "most_frequent")]
     MOST_FREQUENT,
 }
 
@@ -60,3 +45,46 @@ impl ToString for ListStreamComputeAggregation {
         }
     }
 }
+
+impl Serialize for ListStreamComputeAggregation {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ListStreamComputeAggregation {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "count" => Self::COUNT,
+            "cardinality" => Self::CARDINALITY,
+            "median" => Self::MEDIAN,
+            "pc75" => Self::PC75,
+            "pc90" => Self::PC90,
+            "pc95" => Self::PC95,
+            "pc98" => Self::PC98,
+            "pc99" => Self::PC99,
+            "sum" => Self::SUM,
+            "min" => Self::MIN,
+            "max" => Self::MAX,
+            "avg" => Self::AVG,
+            "earliest" => Self::EARLIEST,
+            "latest" => Self::LATEST,
+            "most_frequent" => Self::MOST_FREQUENT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_list_stream_response_format.rs b/src/datadogV1/model/model_list_stream_response_format.rs
index 8fe5f22f0..8eee783c2 100644
--- a/src/datadogV1/model/model_list_stream_response_format.rs
+++ b/src/datadogV1/model/model_list_stream_response_format.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ListStreamResponseFormat {
-    #[serde(rename = "event_list")]
     EVENT_LIST,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ListStreamResponseFormat {
         }
     }
 }
+
+impl Serialize for ListStreamResponseFormat {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ListStreamResponseFormat {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "event_list" => Self::EVENT_LIST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_list_stream_source.rs b/src/datadogV1/model/model_list_stream_source.rs
index 7b9e2e82f..dde2f0f77 100644
--- a/src/datadogV1/model/model_list_stream_source.rs
+++ b/src/datadogV1/model/model_list_stream_source.rs
@@ -2,32 +2,21 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ListStreamSource {
-    #[serde(rename = "logs_stream")]
     LOGS_STREAM,
-    #[serde(rename = "audit_stream")]
     AUDIT_STREAM,
-    #[serde(rename = "ci_pipeline_stream")]
     CI_PIPELINE_STREAM,
-    #[serde(rename = "ci_test_stream")]
     CI_TEST_STREAM,
-    #[serde(rename = "rum_issue_stream")]
     RUM_ISSUE_STREAM,
-    #[serde(rename = "apm_issue_stream")]
     APM_ISSUE_STREAM,
-    #[serde(rename = "trace_stream")]
     TRACE_STREAM,
-    #[serde(rename = "logs_issue_stream")]
     LOGS_ISSUE_STREAM,
-    #[serde(rename = "logs_pattern_stream")]
     LOGS_PATTERN_STREAM,
-    #[serde(rename = "logs_transaction_stream")]
     LOGS_TRANSACTION_STREAM,
-    #[serde(rename = "event_stream")]
     EVENT_STREAM,
 }
 
@@ -48,3 +37,42 @@ impl ToString for ListStreamSource {
         }
     }
 }
+
+impl Serialize for ListStreamSource {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ListStreamSource {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "logs_stream" => Self::LOGS_STREAM,
+            "audit_stream" => Self::AUDIT_STREAM,
+            "ci_pipeline_stream" => Self::CI_PIPELINE_STREAM,
+            "ci_test_stream" => Self::CI_TEST_STREAM,
+            "rum_issue_stream" => Self::RUM_ISSUE_STREAM,
+            "apm_issue_stream" => Self::APM_ISSUE_STREAM,
+            "trace_stream" => Self::TRACE_STREAM,
+            "logs_issue_stream" => Self::LOGS_ISSUE_STREAM,
+            "logs_pattern_stream" => Self::LOGS_PATTERN_STREAM,
+            "logs_transaction_stream" => Self::LOGS_TRANSACTION_STREAM,
+            "event_stream" => Self::EVENT_STREAM,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_list_stream_widget_definition_type.rs b/src/datadogV1/model/model_list_stream_widget_definition_type.rs
index 3bdf43340..cc0c524e8 100644
--- a/src/datadogV1/model/model_list_stream_widget_definition_type.rs
+++ b/src/datadogV1/model/model_list_stream_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ListStreamWidgetDefinitionType {
-    #[serde(rename = "list_stream")]
     LIST_STREAM,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ListStreamWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for ListStreamWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ListStreamWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "list_stream" => Self::LIST_STREAM,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_log_stream_widget_definition_type.rs b/src/datadogV1/model/model_log_stream_widget_definition_type.rs
index 6cf238306..42f1bdcc7 100644
--- a/src/datadogV1/model/model_log_stream_widget_definition_type.rs
+++ b/src/datadogV1/model/model_log_stream_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogStreamWidgetDefinitionType {
-    #[serde(rename = "log_stream")]
     LOG_STREAM,
 }
 
@@ -18,3 +17,32 @@ impl ToString for LogStreamWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for LogStreamWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogStreamWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "log_stream" => Self::LOG_STREAM,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_logs_arithmetic_processor_type.rs b/src/datadogV1/model/model_logs_arithmetic_processor_type.rs
index 1575a6ccc..ebf920a81 100644
--- a/src/datadogV1/model/model_logs_arithmetic_processor_type.rs
+++ b/src/datadogV1/model/model_logs_arithmetic_processor_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsArithmeticProcessorType {
-    #[serde(rename = "arithmetic-processor")]
     ARITHMETIC_PROCESSOR,
 }
 
@@ -18,3 +17,32 @@ impl ToString for LogsArithmeticProcessorType {
         }
     }
 }
+
+impl Serialize for LogsArithmeticProcessorType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsArithmeticProcessorType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "arithmetic-processor" => Self::ARITHMETIC_PROCESSOR,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_logs_attribute_remapper_type.rs b/src/datadogV1/model/model_logs_attribute_remapper_type.rs
index 1d8037382..ca96b14a7 100644
--- a/src/datadogV1/model/model_logs_attribute_remapper_type.rs
+++ b/src/datadogV1/model/model_logs_attribute_remapper_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsAttributeRemapperType {
-    #[serde(rename = "attribute-remapper")]
     ATTRIBUTE_REMAPPER,
 }
 
@@ -18,3 +17,32 @@ impl ToString for LogsAttributeRemapperType {
         }
     }
 }
+
+impl Serialize for LogsAttributeRemapperType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsAttributeRemapperType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "attribute-remapper" => Self::ATTRIBUTE_REMAPPER,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_logs_category_processor_type.rs b/src/datadogV1/model/model_logs_category_processor_type.rs
index b472bb05c..36b931c19 100644
--- a/src/datadogV1/model/model_logs_category_processor_type.rs
+++ b/src/datadogV1/model/model_logs_category_processor_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsCategoryProcessorType {
-    #[serde(rename = "category-processor")]
     CATEGORY_PROCESSOR,
 }
 
@@ -18,3 +17,32 @@ impl ToString for LogsCategoryProcessorType {
         }
     }
 }
+
+impl Serialize for LogsCategoryProcessorType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsCategoryProcessorType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "category-processor" => Self::CATEGORY_PROCESSOR,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_logs_date_remapper_type.rs b/src/datadogV1/model/model_logs_date_remapper_type.rs
index 98b588d28..220585167 100644
--- a/src/datadogV1/model/model_logs_date_remapper_type.rs
+++ b/src/datadogV1/model/model_logs_date_remapper_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsDateRemapperType {
-    #[serde(rename = "date-remapper")]
     DATE_REMAPPER,
 }
 
@@ -18,3 +17,32 @@ impl ToString for LogsDateRemapperType {
         }
     }
 }
+
+impl Serialize for LogsDateRemapperType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsDateRemapperType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "date-remapper" => Self::DATE_REMAPPER,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_logs_geo_ip_parser_type.rs b/src/datadogV1/model/model_logs_geo_ip_parser_type.rs
index 923765330..94d64110f 100644
--- a/src/datadogV1/model/model_logs_geo_ip_parser_type.rs
+++ b/src/datadogV1/model/model_logs_geo_ip_parser_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsGeoIPParserType {
-    #[serde(rename = "geo-ip-parser")]
     GEO_IP_PARSER,
 }
 
@@ -18,3 +17,32 @@ impl ToString for LogsGeoIPParserType {
         }
     }
 }
+
+impl Serialize for LogsGeoIPParserType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsGeoIPParserType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "geo-ip-parser" => Self::GEO_IP_PARSER,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_logs_grok_parser_type.rs b/src/datadogV1/model/model_logs_grok_parser_type.rs
index 7f57bf780..b2a46dd22 100644
--- a/src/datadogV1/model/model_logs_grok_parser_type.rs
+++ b/src/datadogV1/model/model_logs_grok_parser_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsGrokParserType {
-    #[serde(rename = "grok-parser")]
     GROK_PARSER,
 }
 
@@ -18,3 +17,32 @@ impl ToString for LogsGrokParserType {
         }
     }
 }
+
+impl Serialize for LogsGrokParserType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsGrokParserType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "grok-parser" => Self::GROK_PARSER,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_logs_lookup_processor_type.rs b/src/datadogV1/model/model_logs_lookup_processor_type.rs
index e618b1516..625e8caf9 100644
--- a/src/datadogV1/model/model_logs_lookup_processor_type.rs
+++ b/src/datadogV1/model/model_logs_lookup_processor_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsLookupProcessorType {
-    #[serde(rename = "lookup-processor")]
     LOOKUP_PROCESSOR,
 }
 
@@ -18,3 +17,32 @@ impl ToString for LogsLookupProcessorType {
         }
     }
 }
+
+impl Serialize for LogsLookupProcessorType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsLookupProcessorType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "lookup-processor" => Self::LOOKUP_PROCESSOR,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_logs_message_remapper_type.rs b/src/datadogV1/model/model_logs_message_remapper_type.rs
index 6ba81f077..7316b0504 100644
--- a/src/datadogV1/model/model_logs_message_remapper_type.rs
+++ b/src/datadogV1/model/model_logs_message_remapper_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsMessageRemapperType {
-    #[serde(rename = "message-remapper")]
     MESSAGE_REMAPPER,
 }
 
@@ -18,3 +17,32 @@ impl ToString for LogsMessageRemapperType {
         }
     }
 }
+
+impl Serialize for LogsMessageRemapperType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsMessageRemapperType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "message-remapper" => Self::MESSAGE_REMAPPER,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_logs_pipeline_processor_type.rs b/src/datadogV1/model/model_logs_pipeline_processor_type.rs
index 7c2872499..64a5157d6 100644
--- a/src/datadogV1/model/model_logs_pipeline_processor_type.rs
+++ b/src/datadogV1/model/model_logs_pipeline_processor_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsPipelineProcessorType {
-    #[serde(rename = "pipeline")]
     PIPELINE,
 }
 
@@ -18,3 +17,32 @@ impl ToString for LogsPipelineProcessorType {
         }
     }
 }
+
+impl Serialize for LogsPipelineProcessorType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsPipelineProcessorType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "pipeline" => Self::PIPELINE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_logs_service_remapper_type.rs b/src/datadogV1/model/model_logs_service_remapper_type.rs
index 689a1ee16..c0584976c 100644
--- a/src/datadogV1/model/model_logs_service_remapper_type.rs
+++ b/src/datadogV1/model/model_logs_service_remapper_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsServiceRemapperType {
-    #[serde(rename = "service-remapper")]
     SERVICE_REMAPPER,
 }
 
@@ -18,3 +17,32 @@ impl ToString for LogsServiceRemapperType {
         }
     }
 }
+
+impl Serialize for LogsServiceRemapperType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsServiceRemapperType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "service-remapper" => Self::SERVICE_REMAPPER,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_logs_sort.rs b/src/datadogV1/model/model_logs_sort.rs
index ae7a6141f..5aa7b57b0 100644
--- a/src/datadogV1/model/model_logs_sort.rs
+++ b/src/datadogV1/model/model_logs_sort.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsSort {
-    #[serde(rename = "asc")]
     TIME_ASCENDING,
-    #[serde(rename = "desc")]
     TIME_DESCENDING,
 }
 
@@ -21,3 +19,33 @@ impl ToString for LogsSort {
         }
     }
 }
+
+impl Serialize for LogsSort {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsSort {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "asc" => Self::TIME_ASCENDING,
+            "desc" => Self::TIME_DESCENDING,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_logs_status_remapper_type.rs b/src/datadogV1/model/model_logs_status_remapper_type.rs
index b03a1e9ec..1ea3d21f0 100644
--- a/src/datadogV1/model/model_logs_status_remapper_type.rs
+++ b/src/datadogV1/model/model_logs_status_remapper_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsStatusRemapperType {
-    #[serde(rename = "status-remapper")]
     STATUS_REMAPPER,
 }
 
@@ -18,3 +17,32 @@ impl ToString for LogsStatusRemapperType {
         }
     }
 }
+
+impl Serialize for LogsStatusRemapperType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsStatusRemapperType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "status-remapper" => Self::STATUS_REMAPPER,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_logs_string_builder_processor_type.rs b/src/datadogV1/model/model_logs_string_builder_processor_type.rs
index a594f42ef..364dea8ee 100644
--- a/src/datadogV1/model/model_logs_string_builder_processor_type.rs
+++ b/src/datadogV1/model/model_logs_string_builder_processor_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsStringBuilderProcessorType {
-    #[serde(rename = "string-builder-processor")]
     STRING_BUILDER_PROCESSOR,
 }
 
@@ -18,3 +17,32 @@ impl ToString for LogsStringBuilderProcessorType {
         }
     }
 }
+
+impl Serialize for LogsStringBuilderProcessorType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsStringBuilderProcessorType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "string-builder-processor" => Self::STRING_BUILDER_PROCESSOR,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_logs_trace_remapper_type.rs b/src/datadogV1/model/model_logs_trace_remapper_type.rs
index 80289bb91..b169f6326 100644
--- a/src/datadogV1/model/model_logs_trace_remapper_type.rs
+++ b/src/datadogV1/model/model_logs_trace_remapper_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsTraceRemapperType {
-    #[serde(rename = "trace-id-remapper")]
     TRACE_ID_REMAPPER,
 }
 
@@ -18,3 +17,32 @@ impl ToString for LogsTraceRemapperType {
         }
     }
 }
+
+impl Serialize for LogsTraceRemapperType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsTraceRemapperType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "trace-id-remapper" => Self::TRACE_ID_REMAPPER,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_logs_url_parser_type.rs b/src/datadogV1/model/model_logs_url_parser_type.rs
index 025dcce5a..9df990ee8 100644
--- a/src/datadogV1/model/model_logs_url_parser_type.rs
+++ b/src/datadogV1/model/model_logs_url_parser_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsURLParserType {
-    #[serde(rename = "url-parser")]
     URL_PARSER,
 }
 
@@ -18,3 +17,32 @@ impl ToString for LogsURLParserType {
         }
     }
 }
+
+impl Serialize for LogsURLParserType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsURLParserType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "url-parser" => Self::URL_PARSER,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_logs_user_agent_parser_type.rs b/src/datadogV1/model/model_logs_user_agent_parser_type.rs
index c28bccd9d..9e1a97dfd 100644
--- a/src/datadogV1/model/model_logs_user_agent_parser_type.rs
+++ b/src/datadogV1/model/model_logs_user_agent_parser_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsUserAgentParserType {
-    #[serde(rename = "user-agent-parser")]
     USER_AGENT_PARSER,
 }
 
@@ -18,3 +17,32 @@ impl ToString for LogsUserAgentParserType {
         }
     }
 }
+
+impl Serialize for LogsUserAgentParserType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsUserAgentParserType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "user-agent-parser" => Self::USER_AGENT_PARSER,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_metric_content_encoding.rs b/src/datadogV1/model/model_metric_content_encoding.rs
index 3f3c4ae5f..edb393d25 100644
--- a/src/datadogV1/model/model_metric_content_encoding.rs
+++ b/src/datadogV1/model/model_metric_content_encoding.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MetricContentEncoding {
-    #[serde(rename = "deflate")]
     DEFLATE,
-    #[serde(rename = "gzip")]
     GZIP,
 }
 
@@ -21,3 +19,33 @@ impl ToString for MetricContentEncoding {
         }
     }
 }
+
+impl Serialize for MetricContentEncoding {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MetricContentEncoding {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "deflate" => Self::DEFLATE,
+            "gzip" => Self::GZIP,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_monitor_device_id.rs b/src/datadogV1/model/model_monitor_device_id.rs
index 8531cc769..d691b0f2a 100644
--- a/src/datadogV1/model/model_monitor_device_id.rs
+++ b/src/datadogV1/model/model_monitor_device_id.rs
@@ -2,28 +2,19 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MonitorDeviceID {
-    #[serde(rename = "laptop_large")]
     LAPTOP_LARGE,
-    #[serde(rename = "tablet")]
     TABLET,
-    #[serde(rename = "mobile_small")]
     MOBILE_SMALL,
-    #[serde(rename = "chrome.laptop_large")]
     CHROME_LAPTOP_LARGE,
-    #[serde(rename = "chrome.tablet")]
     CHROME_TABLET,
-    #[serde(rename = "chrome.mobile_small")]
     CHROME_MOBILE_SMALL,
-    #[serde(rename = "firefox.laptop_large")]
     FIREFOX_LAPTOP_LARGE,
-    #[serde(rename = "firefox.tablet")]
     FIREFOX_TABLET,
-    #[serde(rename = "firefox.mobile_small")]
     FIREFOX_MOBILE_SMALL,
 }
 
@@ -42,3 +33,40 @@ impl ToString for MonitorDeviceID {
         }
     }
 }
+
+impl Serialize for MonitorDeviceID {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MonitorDeviceID {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "laptop_large" => Self::LAPTOP_LARGE,
+            "tablet" => Self::TABLET,
+            "mobile_small" => Self::MOBILE_SMALL,
+            "chrome.laptop_large" => Self::CHROME_LAPTOP_LARGE,
+            "chrome.tablet" => Self::CHROME_TABLET,
+            "chrome.mobile_small" => Self::CHROME_MOBILE_SMALL,
+            "firefox.laptop_large" => Self::FIREFOX_LAPTOP_LARGE,
+            "firefox.tablet" => Self::FIREFOX_TABLET,
+            "firefox.mobile_small" => Self::FIREFOX_MOBILE_SMALL,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_monitor_formula_and_function_event_aggregation.rs b/src/datadogV1/model/model_monitor_formula_and_function_event_aggregation.rs
index 2848ca8ba..cfcb8591b 100644
--- a/src/datadogV1/model/model_monitor_formula_and_function_event_aggregation.rs
+++ b/src/datadogV1/model/model_monitor_formula_and_function_event_aggregation.rs
@@ -2,34 +2,22 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MonitorFormulaAndFunctionEventAggregation {
-    #[serde(rename = "count")]
     COUNT,
-    #[serde(rename = "cardinality")]
     CARDINALITY,
-    #[serde(rename = "median")]
     MEDIAN,
-    #[serde(rename = "pc75")]
     PC75,
-    #[serde(rename = "pc90")]
     PC90,
-    #[serde(rename = "pc95")]
     PC95,
-    #[serde(rename = "pc98")]
     PC98,
-    #[serde(rename = "pc99")]
     PC99,
-    #[serde(rename = "sum")]
     SUM,
-    #[serde(rename = "min")]
     MIN,
-    #[serde(rename = "max")]
     MAX,
-    #[serde(rename = "avg")]
     AVG,
 }
 
@@ -51,3 +39,43 @@ impl ToString for MonitorFormulaAndFunctionEventAggregation {
         }
     }
 }
+
+impl Serialize for MonitorFormulaAndFunctionEventAggregation {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MonitorFormulaAndFunctionEventAggregation {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "count" => Self::COUNT,
+            "cardinality" => Self::CARDINALITY,
+            "median" => Self::MEDIAN,
+            "pc75" => Self::PC75,
+            "pc90" => Self::PC90,
+            "pc95" => Self::PC95,
+            "pc98" => Self::PC98,
+            "pc99" => Self::PC99,
+            "sum" => Self::SUM,
+            "min" => Self::MIN,
+            "max" => Self::MAX,
+            "avg" => Self::AVG,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_monitor_formula_and_function_events_data_source.rs b/src/datadogV1/model/model_monitor_formula_and_function_events_data_source.rs
index 0503b6dfb..3e42afc1d 100644
--- a/src/datadogV1/model/model_monitor_formula_and_function_events_data_source.rs
+++ b/src/datadogV1/model/model_monitor_formula_and_function_events_data_source.rs
@@ -2,24 +2,17 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MonitorFormulaAndFunctionEventsDataSource {
-    #[serde(rename = "rum")]
     RUM,
-    #[serde(rename = "ci_pipelines")]
     CI_PIPELINES,
-    #[serde(rename = "ci_tests")]
     CI_TESTS,
-    #[serde(rename = "audit")]
     AUDIT,
-    #[serde(rename = "events")]
     EVENTS,
-    #[serde(rename = "logs")]
     LOGS,
-    #[serde(rename = "spans")]
     SPANS,
 }
 
@@ -36,3 +29,38 @@ impl ToString for MonitorFormulaAndFunctionEventsDataSource {
         }
     }
 }
+
+impl Serialize for MonitorFormulaAndFunctionEventsDataSource {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MonitorFormulaAndFunctionEventsDataSource {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "rum" => Self::RUM,
+            "ci_pipelines" => Self::CI_PIPELINES,
+            "ci_tests" => Self::CI_TESTS,
+            "audit" => Self::AUDIT,
+            "events" => Self::EVENTS,
+            "logs" => Self::LOGS,
+            "spans" => Self::SPANS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_monitor_options_notification_presets.rs b/src/datadogV1/model/model_monitor_options_notification_presets.rs
index f368f4112..ff6107a9b 100644
--- a/src/datadogV1/model/model_monitor_options_notification_presets.rs
+++ b/src/datadogV1/model/model_monitor_options_notification_presets.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MonitorOptionsNotificationPresets {
-    #[serde(rename = "show_all")]
     SHOW_ALL,
-    #[serde(rename = "hide_query")]
     HIDE_QUERY,
-    #[serde(rename = "hide_handles")]
     HIDE_HANDLES,
-    #[serde(rename = "hide_all")]
     HIDE_ALL,
 }
 
@@ -27,3 +23,35 @@ impl ToString for MonitorOptionsNotificationPresets {
         }
     }
 }
+
+impl Serialize for MonitorOptionsNotificationPresets {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MonitorOptionsNotificationPresets {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "show_all" => Self::SHOW_ALL,
+            "hide_query" => Self::HIDE_QUERY,
+            "hide_handles" => Self::HIDE_HANDLES,
+            "hide_all" => Self::HIDE_ALL,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_monitor_overall_states.rs b/src/datadogV1/model/model_monitor_overall_states.rs
index 0b978e2a1..02d41157f 100644
--- a/src/datadogV1/model/model_monitor_overall_states.rs
+++ b/src/datadogV1/model/model_monitor_overall_states.rs
@@ -2,24 +2,17 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MonitorOverallStates {
-    #[serde(rename = "Alert")]
     ALERT,
-    #[serde(rename = "Ignored")]
     IGNORED,
-    #[serde(rename = "No Data")]
     NO_DATA,
-    #[serde(rename = "OK")]
     OK,
-    #[serde(rename = "Skipped")]
     SKIPPED,
-    #[serde(rename = "Unknown")]
     UNKNOWN,
-    #[serde(rename = "Warn")]
     WARN,
 }
 
@@ -36,3 +29,38 @@ impl ToString for MonitorOverallStates {
         }
     }
 }
+
+impl Serialize for MonitorOverallStates {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MonitorOverallStates {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "Alert" => Self::ALERT,
+            "Ignored" => Self::IGNORED,
+            "No Data" => Self::NO_DATA,
+            "OK" => Self::OK,
+            "Skipped" => Self::SKIPPED,
+            "Unknown" => Self::UNKNOWN,
+            "Warn" => Self::WARN,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_monitor_renotify_status_type.rs b/src/datadogV1/model/model_monitor_renotify_status_type.rs
index 02e9dcbdd..4c6d7eaa5 100644
--- a/src/datadogV1/model/model_monitor_renotify_status_type.rs
+++ b/src/datadogV1/model/model_monitor_renotify_status_type.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MonitorRenotifyStatusType {
-    #[serde(rename = "alert")]
     ALERT,
-    #[serde(rename = "warn")]
     WARN,
-    #[serde(rename = "no data")]
     NO_DATA,
 }
 
@@ -24,3 +21,34 @@ impl ToString for MonitorRenotifyStatusType {
         }
     }
 }
+
+impl Serialize for MonitorRenotifyStatusType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MonitorRenotifyStatusType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "alert" => Self::ALERT,
+            "warn" => Self::WARN,
+            "no data" => Self::NO_DATA,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_monitor_summary_widget_definition_type.rs b/src/datadogV1/model/model_monitor_summary_widget_definition_type.rs
index bf30f4e13..bede6d2ce 100644
--- a/src/datadogV1/model/model_monitor_summary_widget_definition_type.rs
+++ b/src/datadogV1/model/model_monitor_summary_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MonitorSummaryWidgetDefinitionType {
-    #[serde(rename = "manage_status")]
     MANAGE_STATUS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for MonitorSummaryWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for MonitorSummaryWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MonitorSummaryWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "manage_status" => Self::MANAGE_STATUS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_monitor_type.rs b/src/datadogV1/model/model_monitor_type.rs
index 6fb0d3977..f433f29b8 100644
--- a/src/datadogV1/model/model_monitor_type.rs
+++ b/src/datadogV1/model/model_monitor_type.rs
@@ -2,44 +2,27 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MonitorType {
-    #[serde(rename = "composite")]
     COMPOSITE,
-    #[serde(rename = "event alert")]
     EVENT_ALERT,
-    #[serde(rename = "log alert")]
     LOG_ALERT,
-    #[serde(rename = "metric alert")]
     METRIC_ALERT,
-    #[serde(rename = "process alert")]
     PROCESS_ALERT,
-    #[serde(rename = "query alert")]
     QUERY_ALERT,
-    #[serde(rename = "rum alert")]
     RUM_ALERT,
-    #[serde(rename = "service check")]
     SERVICE_CHECK,
-    #[serde(rename = "synthetics alert")]
     SYNTHETICS_ALERT,
-    #[serde(rename = "trace-analytics alert")]
     TRACE_ANALYTICS_ALERT,
-    #[serde(rename = "slo alert")]
     SLO_ALERT,
-    #[serde(rename = "event-v2 alert")]
     EVENT_V2_ALERT,
-    #[serde(rename = "audit alert")]
     AUDIT_ALERT,
-    #[serde(rename = "ci-pipelines alert")]
     CI_PIPELINES_ALERT,
-    #[serde(rename = "ci-tests alert")]
     CI_TESTS_ALERT,
-    #[serde(rename = "error-tracking alert")]
     ERROR_TRACKING_ALERT,
-    #[serde(rename = "database-monitoring alert")]
     DATABASE_MONITORING_ALERT,
 }
 
@@ -66,3 +49,48 @@ impl ToString for MonitorType {
         }
     }
 }
+
+impl Serialize for MonitorType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MonitorType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "composite" => Self::COMPOSITE,
+            "event alert" => Self::EVENT_ALERT,
+            "log alert" => Self::LOG_ALERT,
+            "metric alert" => Self::METRIC_ALERT,
+            "process alert" => Self::PROCESS_ALERT,
+            "query alert" => Self::QUERY_ALERT,
+            "rum alert" => Self::RUM_ALERT,
+            "service check" => Self::SERVICE_CHECK,
+            "synthetics alert" => Self::SYNTHETICS_ALERT,
+            "trace-analytics alert" => Self::TRACE_ANALYTICS_ALERT,
+            "slo alert" => Self::SLO_ALERT,
+            "event-v2 alert" => Self::EVENT_V2_ALERT,
+            "audit alert" => Self::AUDIT_ALERT,
+            "ci-pipelines alert" => Self::CI_PIPELINES_ALERT,
+            "ci-tests alert" => Self::CI_TESTS_ALERT,
+            "error-tracking alert" => Self::ERROR_TRACKING_ALERT,
+            "database-monitoring alert" => Self::DATABASE_MONITORING_ALERT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_monthly_usage_attribution_supported_metrics.rs b/src/datadogV1/model/model_monthly_usage_attribution_supported_metrics.rs
index aef321eba..ae9481273 100644
--- a/src/datadogV1/model/model_monthly_usage_attribution_supported_metrics.rs
+++ b/src/datadogV1/model/model_monthly_usage_attribution_supported_metrics.rs
@@ -2,252 +2,131 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MonthlyUsageAttributionSupportedMetrics {
-    #[serde(rename = "api_usage")]
     API_USAGE,
-    #[serde(rename = "api_percentage")]
     API_PERCENTAGE,
-    #[serde(rename = "apm_fargate_usage")]
     APM_FARGATE_USAGE,
-    #[serde(rename = "apm_fargate_percentage")]
     APM_FARGATE_PERCENTAGE,
-    #[serde(rename = "appsec_fargate_usage")]
     APPSEC_FARGATE_USAGE,
-    #[serde(rename = "appsec_fargate_percentage")]
     APPSEC_FARGATE_PERCENTAGE,
-    #[serde(rename = "apm_host_usage")]
     APM_HOST_USAGE,
-    #[serde(rename = "apm_host_percentage")]
     APM_HOST_PERCENTAGE,
-    #[serde(rename = "apm_usm_usage")]
     APM_USM_USAGE,
-    #[serde(rename = "apm_usm_percentage")]
     APM_USM_PERCENTAGE,
-    #[serde(rename = "appsec_usage")]
     APPSEC_USAGE,
-    #[serde(rename = "appsec_percentage")]
     APPSEC_PERCENTAGE,
-    #[serde(rename = "browser_usage")]
     BROWSER_USAGE,
-    #[serde(rename = "browser_percentage")]
     BROWSER_PERCENTAGE,
-    #[serde(rename = "ci_visibility_itr_usage")]
     CI_VISIBILITY_ITR_USAGE,
-    #[serde(rename = "ci_visibility_itr_percentage")]
     CI_VISIBILITY_ITR_PERCENTAGE,
-    #[serde(rename = "cloud_siem_usage")]
     CLOUD_SIEM_USAGE,
-    #[serde(rename = "cloud_siem_percentage")]
     CLOUD_SIEM_PERCENTAGE,
-    #[serde(rename = "container_excl_agent_usage")]
     CONTAINER_EXCL_AGENT_USAGE,
-    #[serde(rename = "container_excl_agent_percentage")]
     CONTAINER_EXCL_AGENT_PERCENTAGE,
-    #[serde(rename = "container_usage")]
     CONTAINER_USAGE,
-    #[serde(rename = "container_percentage")]
     CONTAINER_PERCENTAGE,
-    #[serde(rename = "cspm_containers_percentage")]
     CSPM_CONTAINERS_PERCENTAGE,
-    #[serde(rename = "cspm_containers_usage")]
     CSPM_CONTAINERS_USAGE,
-    #[serde(rename = "cspm_hosts_percentage")]
     CSPM_HOSTS_PERCENTAGE,
-    #[serde(rename = "cspm_hosts_usage")]
     CSPM_HOSTS_USAGE,
-    #[serde(rename = "custom_timeseries_usage")]
     CUSTOM_TIMESERIES_USAGE,
-    #[serde(rename = "custom_timeseries_percentage")]
     CUSTOM_TIMESERIES_PERCENTAGE,
-    #[serde(rename = "custom_ingested_timeseries_usage")]
     CUSTOM_INGESTED_TIMESERIES_USAGE,
-    #[serde(rename = "custom_ingested_timeseries_percentage")]
     CUSTOM_INGESTED_TIMESERIES_PERCENTAGE,
-    #[serde(rename = "cws_containers_percentage")]
     CWS_CONTAINERS_PERCENTAGE,
-    #[serde(rename = "cws_containers_usage")]
     CWS_CONTAINERS_USAGE,
-    #[serde(rename = "cws_hosts_percentage")]
     CWS_HOSTS_PERCENTAGE,
-    #[serde(rename = "cws_hosts_usage")]
     CWS_HOSTS_USAGE,
-    #[serde(rename = "dbm_hosts_percentage")]
     DBM_HOSTS_PERCENTAGE,
-    #[serde(rename = "dbm_hosts_usage")]
     DBM_HOSTS_USAGE,
-    #[serde(rename = "dbm_queries_percentage")]
     DBM_QUERIES_PERCENTAGE,
-    #[serde(rename = "dbm_queries_usage")]
     DBM_QUERIES_USAGE,
-    #[serde(rename = "estimated_indexed_logs_usage")]
     ESTIMATED_INDEXED_LOGS_USAGE,
-    #[serde(rename = "estimated_indexed_logs_percentage")]
     ESTIMATED_INDEXED_LOGS_PERCENTAGE,
-    #[serde(rename = "estimated_ingested_logs_usage")]
     ESTIMATED_INGESTED_LOGS_USAGE,
-    #[serde(rename = "estimated_ingested_logs_percentage")]
     ESTIMATED_INGESTED_LOGS_PERCENTAGE,
-    #[serde(rename = "estimated_indexed_spans_usage")]
     ESTIMATED_INDEXED_SPANS_USAGE,
-    #[serde(rename = "estimated_indexed_spans_percentage")]
     ESTIMATED_INDEXED_SPANS_PERCENTAGE,
-    #[serde(rename = "estimated_ingested_spans_usage")]
     ESTIMATED_INGESTED_SPANS_USAGE,
-    #[serde(rename = "estimated_ingested_spans_percentage")]
     ESTIMATED_INGESTED_SPANS_PERCENTAGE,
-    #[serde(rename = "fargate_usage")]
     FARGATE_USAGE,
-    #[serde(rename = "fargate_percentage")]
     FARGATE_PERCENTAGE,
-    #[serde(rename = "functions_usage")]
     FUNCTIONS_USAGE,
-    #[serde(rename = "functions_percentage")]
     FUNCTIONS_PERCENTAGE,
-    #[serde(rename = "infra_host_usage")]
     INFRA_HOST_USAGE,
-    #[serde(rename = "infra_host_percentage")]
     INFRA_HOST_PERCENTAGE,
-    #[serde(rename = "invocations_usage")]
     INVOCATIONS_USAGE,
-    #[serde(rename = "invocations_percentage")]
     INVOCATIONS_PERCENTAGE,
-    #[serde(rename = "lambda_traced_invocations_usage")]
     LAMBDA_TRACED_INVOCATIONS_USAGE,
-    #[serde(rename = "lambda_traced_invocations_percentage")]
     LAMBDA_TRACED_INVOCATIONS_PERCENTAGE,
-    #[serde(rename = "mobile_app_testing_percentage")]
     MOBILE_APP_TESTING_USAGE,
-    #[serde(rename = "mobile_app_testing_usage")]
     MOBILE_APP_TESTING_PERCENTAGE,
-    #[serde(rename = "ndm_netflow_usage")]
     NDM_NETFLOW_USAGE,
-    #[serde(rename = "ndm_netflow_percentage")]
     NDM_NETFLOW_PERCENTAGE,
-    #[serde(rename = "npm_host_usage")]
     NPM_HOST_USAGE,
-    #[serde(rename = "npm_host_percentage")]
     NPM_HOST_PERCENTAGE,
-    #[serde(rename = "obs_pipeline_bytes_usage")]
     OBS_PIPELINE_BYTES_USAGE,
-    #[serde(rename = "obs_pipeline_bytes_percentage")]
     OBS_PIPELINE_BYTES_PERCENTAGE,
-    #[serde(rename = "profiled_container_usage")]
     PROFILED_CONTAINER_USAGE,
-    #[serde(rename = "profiled_container_percentage")]
     PROFILED_CONTAINER_PERCENTAGE,
-    #[serde(rename = "profiled_fargate_usage")]
     PROFILED_FARGATE_USAGE,
-    #[serde(rename = "profiled_fargate_percentage")]
     PROFILED_FARGATE_PERCENTAGE,
-    #[serde(rename = "profiled_host_usage")]
     PROFILED_HOST_USAGE,
-    #[serde(rename = "profiled_host_percentage")]
     PROFILED_HOST_PERCENTAGE,
-    #[serde(rename = "serverless_apps_usage")]
     SERVERLESS_APPS_USAGE,
-    #[serde(rename = "serverless_apps_percentage")]
     SERVERLESS_APPS_PERCENTAGE,
-    #[serde(rename = "snmp_usage")]
     SNMP_USAGE,
-    #[serde(rename = "snmp_percentage")]
     SNMP_PERCENTAGE,
-    #[serde(rename = "estimated_rum_sessions_usage")]
     ESTIMATED_RUM_SESSIONS_USAGE,
-    #[serde(rename = "estimated_rum_sessions_percentage")]
     ESTIMATED_RUM_SESSIONS_PERCENTAGE,
-    #[serde(rename = "universal_service_monitoring_usage")]
     UNIVERSAL_SERVICE_MONITORING_USAGE,
-    #[serde(rename = "universal_service_monitoring_percentage")]
     UNIVERSAL_SERVICE_MONITORING_PERCENTAGE,
-    #[serde(rename = "vuln_management_hosts_usage")]
     VULN_MANAGEMENT_HOSTS_USAGE,
-    #[serde(rename = "vuln_management_hosts_percentage")]
     VULN_MANAGEMENT_HOSTS_PERCENTAGE,
-    #[serde(rename = "sds_scanned_bytes_usage")]
     SDS_SCANNED_BYTES_USAGE,
-    #[serde(rename = "sds_scanned_bytes_percentage")]
     SDS_SCANNED_BYTES_PERCENTAGE,
-    #[serde(rename = "ci_test_indexed_spans_usage")]
     CI_TEST_INDEXED_SPANS_USAGE,
-    #[serde(rename = "ci_test_indexed_spans_percentage")]
     CI_TEST_INDEXED_SPANS_PERCENTAGE,
-    #[serde(rename = "ingested_logs_bytes_usage")]
     INGESTED_LOGS_BYTES_USAGE,
-    #[serde(rename = "ingested_logs_bytes_percentage")]
     INGESTED_LOGS_BYTES_PERCENTAGE,
-    #[serde(rename = "ci_pipeline_indexed_spans_usage")]
     CI_PIPELINE_INDEXED_SPANS_USAGE,
-    #[serde(rename = "ci_pipeline_indexed_spans_percentage")]
     CI_PIPELINE_INDEXED_SPANS_PERCENTAGE,
-    #[serde(rename = "indexed_spans_usage")]
     INDEXED_SPANS_USAGE,
-    #[serde(rename = "indexed_spans_percentage")]
     INDEXED_SPANS_PERCENTAGE,
-    #[serde(rename = "custom_event_usage")]
     CUSTOM_EVENT_USAGE,
-    #[serde(rename = "custom_event_percentage")]
     CUSTOM_EVENT_PERCENTAGE,
-    #[serde(rename = "logs_indexed_custom_retention_usage")]
     LOGS_INDEXED_CUSTOM_RETENTION_USAGE,
-    #[serde(rename = "logs_indexed_custom_retention_percentage")]
     LOGS_INDEXED_CUSTOM_RETENTION_PERCENTAGE,
-    #[serde(rename = "logs_indexed_360day_usage")]
     LOGS_INDEXED_360DAY_USAGE,
-    #[serde(rename = "logs_indexed_360day_percentage")]
     LOGS_INDEXED_360DAY_PERCENTAGE,
-    #[serde(rename = "logs_indexed_180day_usage")]
     LOGS_INDEXED_180DAY_USAGE,
-    #[serde(rename = "logs_indexed_180day_percentage")]
     LOGS_INDEXED_180DAY_PERCENTAGE,
-    #[serde(rename = "logs_indexed_90day_usage")]
     LOGS_INDEXED_90DAY_USAGE,
-    #[serde(rename = "logs_indexed_90day_percentage")]
     LOGS_INDEXED_90DAY_PERCENTAGE,
-    #[serde(rename = "logs_indexed_60day_usage")]
     LOGS_INDEXED_60DAY_USAGE,
-    #[serde(rename = "logs_indexed_60day_percentage")]
     LOGS_INDEXED_60DAY_PERCENTAGE,
-    #[serde(rename = "logs_indexed_45day_usage")]
     LOGS_INDEXED_45DAY_USAGE,
-    #[serde(rename = "logs_indexed_45day_percentage")]
     LOGS_INDEXED_45DAY_PERCENTAGE,
-    #[serde(rename = "logs_indexed_30day_usage")]
     LOGS_INDEXED_30DAY_USAGE,
-    #[serde(rename = "logs_indexed_30day_percentage")]
     LOGS_INDEXED_30DAY_PERCENTAGE,
-    #[serde(rename = "logs_indexed_15day_usage")]
     LOGS_INDEXED_15DAY_USAGE,
-    #[serde(rename = "logs_indexed_15day_percentage")]
     LOGS_INDEXED_15DAY_PERCENTAGE,
-    #[serde(rename = "logs_indexed_7day_usage")]
     LOGS_INDEXED_7DAY_USAGE,
-    #[serde(rename = "logs_indexed_7day_percentage")]
     LOGS_INDEXED_7DAY_PERCENTAGE,
-    #[serde(rename = "logs_indexed_3day_usage")]
     LOGS_INDEXED_3DAY_USAGE,
-    #[serde(rename = "logs_indexed_3day_percentage")]
     LOGS_INDEXED_3DAY_PERCENTAGE,
-    #[serde(rename = "rum_replay_sessions_usage")]
     RUM_REPLAY_SESSIONS_USAGE,
-    #[serde(rename = "rum_replay_sessions_percentage")]
     RUM_REPLAY_SESSIONS_PERCENTAGE,
-    #[serde(rename = "rum_browser_mobile_sessions_usage")]
     RUM_BROWSER_MOBILE_SESSIONS_USAGE,
-    #[serde(rename = "rum_browser_mobile_sessions_percentage")]
     RUM_BROWSER_MOBILE_SESSIONS_PERCENTAGE,
-    #[serde(rename = "ingested_spans_bytes_usage")]
     INGESTED_SPANS_BYTES_USAGE,
-    #[serde(rename = "ingested_spans_bytes_percentage")]
     INGESTED_SPANS_BYTES_PERCENTAGE,
-    #[serde(rename = "siem_ingested_bytes_usage")]
     SIEM_INGESTED_BYTES_USAGE,
-    #[serde(rename = "siem_ingested_bytes_percentage")]
     SIEM_INGESTED_BYTES_PERCENTAGE,
-    #[serde(rename = "*")]
     ALL,
 }
 
@@ -420,3 +299,158 @@ impl ToString for MonthlyUsageAttributionSupportedMetrics {
         }
     }
 }
+
+impl Serialize for MonthlyUsageAttributionSupportedMetrics {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MonthlyUsageAttributionSupportedMetrics {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "api_usage" => Self::API_USAGE,
+            "api_percentage" => Self::API_PERCENTAGE,
+            "apm_fargate_usage" => Self::APM_FARGATE_USAGE,
+            "apm_fargate_percentage" => Self::APM_FARGATE_PERCENTAGE,
+            "appsec_fargate_usage" => Self::APPSEC_FARGATE_USAGE,
+            "appsec_fargate_percentage" => Self::APPSEC_FARGATE_PERCENTAGE,
+            "apm_host_usage" => Self::APM_HOST_USAGE,
+            "apm_host_percentage" => Self::APM_HOST_PERCENTAGE,
+            "apm_usm_usage" => Self::APM_USM_USAGE,
+            "apm_usm_percentage" => Self::APM_USM_PERCENTAGE,
+            "appsec_usage" => Self::APPSEC_USAGE,
+            "appsec_percentage" => Self::APPSEC_PERCENTAGE,
+            "browser_usage" => Self::BROWSER_USAGE,
+            "browser_percentage" => Self::BROWSER_PERCENTAGE,
+            "ci_visibility_itr_usage" => Self::CI_VISIBILITY_ITR_USAGE,
+            "ci_visibility_itr_percentage" => Self::CI_VISIBILITY_ITR_PERCENTAGE,
+            "cloud_siem_usage" => Self::CLOUD_SIEM_USAGE,
+            "cloud_siem_percentage" => Self::CLOUD_SIEM_PERCENTAGE,
+            "container_excl_agent_usage" => Self::CONTAINER_EXCL_AGENT_USAGE,
+            "container_excl_agent_percentage" => Self::CONTAINER_EXCL_AGENT_PERCENTAGE,
+            "container_usage" => Self::CONTAINER_USAGE,
+            "container_percentage" => Self::CONTAINER_PERCENTAGE,
+            "cspm_containers_percentage" => Self::CSPM_CONTAINERS_PERCENTAGE,
+            "cspm_containers_usage" => Self::CSPM_CONTAINERS_USAGE,
+            "cspm_hosts_percentage" => Self::CSPM_HOSTS_PERCENTAGE,
+            "cspm_hosts_usage" => Self::CSPM_HOSTS_USAGE,
+            "custom_timeseries_usage" => Self::CUSTOM_TIMESERIES_USAGE,
+            "custom_timeseries_percentage" => Self::CUSTOM_TIMESERIES_PERCENTAGE,
+            "custom_ingested_timeseries_usage" => Self::CUSTOM_INGESTED_TIMESERIES_USAGE,
+            "custom_ingested_timeseries_percentage" => Self::CUSTOM_INGESTED_TIMESERIES_PERCENTAGE,
+            "cws_containers_percentage" => Self::CWS_CONTAINERS_PERCENTAGE,
+            "cws_containers_usage" => Self::CWS_CONTAINERS_USAGE,
+            "cws_hosts_percentage" => Self::CWS_HOSTS_PERCENTAGE,
+            "cws_hosts_usage" => Self::CWS_HOSTS_USAGE,
+            "dbm_hosts_percentage" => Self::DBM_HOSTS_PERCENTAGE,
+            "dbm_hosts_usage" => Self::DBM_HOSTS_USAGE,
+            "dbm_queries_percentage" => Self::DBM_QUERIES_PERCENTAGE,
+            "dbm_queries_usage" => Self::DBM_QUERIES_USAGE,
+            "estimated_indexed_logs_usage" => Self::ESTIMATED_INDEXED_LOGS_USAGE,
+            "estimated_indexed_logs_percentage" => Self::ESTIMATED_INDEXED_LOGS_PERCENTAGE,
+            "estimated_ingested_logs_usage" => Self::ESTIMATED_INGESTED_LOGS_USAGE,
+            "estimated_ingested_logs_percentage" => Self::ESTIMATED_INGESTED_LOGS_PERCENTAGE,
+            "estimated_indexed_spans_usage" => Self::ESTIMATED_INDEXED_SPANS_USAGE,
+            "estimated_indexed_spans_percentage" => Self::ESTIMATED_INDEXED_SPANS_PERCENTAGE,
+            "estimated_ingested_spans_usage" => Self::ESTIMATED_INGESTED_SPANS_USAGE,
+            "estimated_ingested_spans_percentage" => Self::ESTIMATED_INGESTED_SPANS_PERCENTAGE,
+            "fargate_usage" => Self::FARGATE_USAGE,
+            "fargate_percentage" => Self::FARGATE_PERCENTAGE,
+            "functions_usage" => Self::FUNCTIONS_USAGE,
+            "functions_percentage" => Self::FUNCTIONS_PERCENTAGE,
+            "infra_host_usage" => Self::INFRA_HOST_USAGE,
+            "infra_host_percentage" => Self::INFRA_HOST_PERCENTAGE,
+            "invocations_usage" => Self::INVOCATIONS_USAGE,
+            "invocations_percentage" => Self::INVOCATIONS_PERCENTAGE,
+            "lambda_traced_invocations_usage" => Self::LAMBDA_TRACED_INVOCATIONS_USAGE,
+            "lambda_traced_invocations_percentage" => Self::LAMBDA_TRACED_INVOCATIONS_PERCENTAGE,
+            "mobile_app_testing_percentage" => Self::MOBILE_APP_TESTING_USAGE,
+            "mobile_app_testing_usage" => Self::MOBILE_APP_TESTING_PERCENTAGE,
+            "ndm_netflow_usage" => Self::NDM_NETFLOW_USAGE,
+            "ndm_netflow_percentage" => Self::NDM_NETFLOW_PERCENTAGE,
+            "npm_host_usage" => Self::NPM_HOST_USAGE,
+            "npm_host_percentage" => Self::NPM_HOST_PERCENTAGE,
+            "obs_pipeline_bytes_usage" => Self::OBS_PIPELINE_BYTES_USAGE,
+            "obs_pipeline_bytes_percentage" => Self::OBS_PIPELINE_BYTES_PERCENTAGE,
+            "profiled_container_usage" => Self::PROFILED_CONTAINER_USAGE,
+            "profiled_container_percentage" => Self::PROFILED_CONTAINER_PERCENTAGE,
+            "profiled_fargate_usage" => Self::PROFILED_FARGATE_USAGE,
+            "profiled_fargate_percentage" => Self::PROFILED_FARGATE_PERCENTAGE,
+            "profiled_host_usage" => Self::PROFILED_HOST_USAGE,
+            "profiled_host_percentage" => Self::PROFILED_HOST_PERCENTAGE,
+            "serverless_apps_usage" => Self::SERVERLESS_APPS_USAGE,
+            "serverless_apps_percentage" => Self::SERVERLESS_APPS_PERCENTAGE,
+            "snmp_usage" => Self::SNMP_USAGE,
+            "snmp_percentage" => Self::SNMP_PERCENTAGE,
+            "estimated_rum_sessions_usage" => Self::ESTIMATED_RUM_SESSIONS_USAGE,
+            "estimated_rum_sessions_percentage" => Self::ESTIMATED_RUM_SESSIONS_PERCENTAGE,
+            "universal_service_monitoring_usage" => Self::UNIVERSAL_SERVICE_MONITORING_USAGE,
+            "universal_service_monitoring_percentage" => {
+                Self::UNIVERSAL_SERVICE_MONITORING_PERCENTAGE
+            }
+            "vuln_management_hosts_usage" => Self::VULN_MANAGEMENT_HOSTS_USAGE,
+            "vuln_management_hosts_percentage" => Self::VULN_MANAGEMENT_HOSTS_PERCENTAGE,
+            "sds_scanned_bytes_usage" => Self::SDS_SCANNED_BYTES_USAGE,
+            "sds_scanned_bytes_percentage" => Self::SDS_SCANNED_BYTES_PERCENTAGE,
+            "ci_test_indexed_spans_usage" => Self::CI_TEST_INDEXED_SPANS_USAGE,
+            "ci_test_indexed_spans_percentage" => Self::CI_TEST_INDEXED_SPANS_PERCENTAGE,
+            "ingested_logs_bytes_usage" => Self::INGESTED_LOGS_BYTES_USAGE,
+            "ingested_logs_bytes_percentage" => Self::INGESTED_LOGS_BYTES_PERCENTAGE,
+            "ci_pipeline_indexed_spans_usage" => Self::CI_PIPELINE_INDEXED_SPANS_USAGE,
+            "ci_pipeline_indexed_spans_percentage" => Self::CI_PIPELINE_INDEXED_SPANS_PERCENTAGE,
+            "indexed_spans_usage" => Self::INDEXED_SPANS_USAGE,
+            "indexed_spans_percentage" => Self::INDEXED_SPANS_PERCENTAGE,
+            "custom_event_usage" => Self::CUSTOM_EVENT_USAGE,
+            "custom_event_percentage" => Self::CUSTOM_EVENT_PERCENTAGE,
+            "logs_indexed_custom_retention_usage" => Self::LOGS_INDEXED_CUSTOM_RETENTION_USAGE,
+            "logs_indexed_custom_retention_percentage" => {
+                Self::LOGS_INDEXED_CUSTOM_RETENTION_PERCENTAGE
+            }
+            "logs_indexed_360day_usage" => Self::LOGS_INDEXED_360DAY_USAGE,
+            "logs_indexed_360day_percentage" => Self::LOGS_INDEXED_360DAY_PERCENTAGE,
+            "logs_indexed_180day_usage" => Self::LOGS_INDEXED_180DAY_USAGE,
+            "logs_indexed_180day_percentage" => Self::LOGS_INDEXED_180DAY_PERCENTAGE,
+            "logs_indexed_90day_usage" => Self::LOGS_INDEXED_90DAY_USAGE,
+            "logs_indexed_90day_percentage" => Self::LOGS_INDEXED_90DAY_PERCENTAGE,
+            "logs_indexed_60day_usage" => Self::LOGS_INDEXED_60DAY_USAGE,
+            "logs_indexed_60day_percentage" => Self::LOGS_INDEXED_60DAY_PERCENTAGE,
+            "logs_indexed_45day_usage" => Self::LOGS_INDEXED_45DAY_USAGE,
+            "logs_indexed_45day_percentage" => Self::LOGS_INDEXED_45DAY_PERCENTAGE,
+            "logs_indexed_30day_usage" => Self::LOGS_INDEXED_30DAY_USAGE,
+            "logs_indexed_30day_percentage" => Self::LOGS_INDEXED_30DAY_PERCENTAGE,
+            "logs_indexed_15day_usage" => Self::LOGS_INDEXED_15DAY_USAGE,
+            "logs_indexed_15day_percentage" => Self::LOGS_INDEXED_15DAY_PERCENTAGE,
+            "logs_indexed_7day_usage" => Self::LOGS_INDEXED_7DAY_USAGE,
+            "logs_indexed_7day_percentage" => Self::LOGS_INDEXED_7DAY_PERCENTAGE,
+            "logs_indexed_3day_usage" => Self::LOGS_INDEXED_3DAY_USAGE,
+            "logs_indexed_3day_percentage" => Self::LOGS_INDEXED_3DAY_PERCENTAGE,
+            "rum_replay_sessions_usage" => Self::RUM_REPLAY_SESSIONS_USAGE,
+            "rum_replay_sessions_percentage" => Self::RUM_REPLAY_SESSIONS_PERCENTAGE,
+            "rum_browser_mobile_sessions_usage" => Self::RUM_BROWSER_MOBILE_SESSIONS_USAGE,
+            "rum_browser_mobile_sessions_percentage" => {
+                Self::RUM_BROWSER_MOBILE_SESSIONS_PERCENTAGE
+            }
+            "ingested_spans_bytes_usage" => Self::INGESTED_SPANS_BYTES_USAGE,
+            "ingested_spans_bytes_percentage" => Self::INGESTED_SPANS_BYTES_PERCENTAGE,
+            "siem_ingested_bytes_usage" => Self::SIEM_INGESTED_BYTES_USAGE,
+            "siem_ingested_bytes_percentage" => Self::SIEM_INGESTED_BYTES_PERCENTAGE,
+            "*" => Self::ALL,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_note_widget_definition_type.rs b/src/datadogV1/model/model_note_widget_definition_type.rs
index ddb164f6f..fa8119af8 100644
--- a/src/datadogV1/model/model_note_widget_definition_type.rs
+++ b/src/datadogV1/model/model_note_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum NoteWidgetDefinitionType {
-    #[serde(rename = "note")]
     NOTE,
 }
 
@@ -18,3 +17,32 @@ impl ToString for NoteWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for NoteWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for NoteWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "note" => Self::NOTE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_notebook_cell_resource_type.rs b/src/datadogV1/model/model_notebook_cell_resource_type.rs
index 1cef6b73c..f610f6fe1 100644
--- a/src/datadogV1/model/model_notebook_cell_resource_type.rs
+++ b/src/datadogV1/model/model_notebook_cell_resource_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum NotebookCellResourceType {
-    #[serde(rename = "notebook_cells")]
     NOTEBOOK_CELLS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for NotebookCellResourceType {
         }
     }
 }
+
+impl Serialize for NotebookCellResourceType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for NotebookCellResourceType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "notebook_cells" => Self::NOTEBOOK_CELLS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_notebook_graph_size.rs b/src/datadogV1/model/model_notebook_graph_size.rs
index aa7869955..90360e037 100644
--- a/src/datadogV1/model/model_notebook_graph_size.rs
+++ b/src/datadogV1/model/model_notebook_graph_size.rs
@@ -2,20 +2,15 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum NotebookGraphSize {
-    #[serde(rename = "xs")]
     EXTRA_SMALL,
-    #[serde(rename = "s")]
     SMALL,
-    #[serde(rename = "m")]
     MEDIUM,
-    #[serde(rename = "l")]
     LARGE,
-    #[serde(rename = "xl")]
     EXTRA_LARGE,
 }
 
@@ -30,3 +25,36 @@ impl ToString for NotebookGraphSize {
         }
     }
 }
+
+impl Serialize for NotebookGraphSize {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for NotebookGraphSize {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "xs" => Self::EXTRA_SMALL,
+            "s" => Self::SMALL,
+            "m" => Self::MEDIUM,
+            "l" => Self::LARGE,
+            "xl" => Self::EXTRA_LARGE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_notebook_markdown_cell_definition_type.rs b/src/datadogV1/model/model_notebook_markdown_cell_definition_type.rs
index ae8ca3740..f33969fdd 100644
--- a/src/datadogV1/model/model_notebook_markdown_cell_definition_type.rs
+++ b/src/datadogV1/model/model_notebook_markdown_cell_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum NotebookMarkdownCellDefinitionType {
-    #[serde(rename = "markdown")]
     MARKDOWN,
 }
 
@@ -18,3 +17,32 @@ impl ToString for NotebookMarkdownCellDefinitionType {
         }
     }
 }
+
+impl Serialize for NotebookMarkdownCellDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for NotebookMarkdownCellDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "markdown" => Self::MARKDOWN,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_notebook_metadata_type.rs b/src/datadogV1/model/model_notebook_metadata_type.rs
index 2a1ef80ef..657709e01 100644
--- a/src/datadogV1/model/model_notebook_metadata_type.rs
+++ b/src/datadogV1/model/model_notebook_metadata_type.rs
@@ -2,20 +2,15 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum NotebookMetadataType {
-    #[serde(rename = "postmortem")]
     POSTMORTEM,
-    #[serde(rename = "runbook")]
     RUNBOOK,
-    #[serde(rename = "investigation")]
     INVESTIGATION,
-    #[serde(rename = "documentation")]
     DOCUMENTATION,
-    #[serde(rename = "report")]
     REPORT,
 }
 
@@ -30,3 +25,36 @@ impl ToString for NotebookMetadataType {
         }
     }
 }
+
+impl Serialize for NotebookMetadataType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for NotebookMetadataType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "postmortem" => Self::POSTMORTEM,
+            "runbook" => Self::RUNBOOK,
+            "investigation" => Self::INVESTIGATION,
+            "documentation" => Self::DOCUMENTATION,
+            "report" => Self::REPORT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_notebook_resource_type.rs b/src/datadogV1/model/model_notebook_resource_type.rs
index 7531238f5..8c5f8aa83 100644
--- a/src/datadogV1/model/model_notebook_resource_type.rs
+++ b/src/datadogV1/model/model_notebook_resource_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum NotebookResourceType {
-    #[serde(rename = "notebooks")]
     NOTEBOOKS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for NotebookResourceType {
         }
     }
 }
+
+impl Serialize for NotebookResourceType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for NotebookResourceType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "notebooks" => Self::NOTEBOOKS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_notebook_status.rs b/src/datadogV1/model/model_notebook_status.rs
index 64564b680..183da8a89 100644
--- a/src/datadogV1/model/model_notebook_status.rs
+++ b/src/datadogV1/model/model_notebook_status.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum NotebookStatus {
-    #[serde(rename = "published")]
     PUBLISHED,
 }
 
@@ -18,3 +17,32 @@ impl ToString for NotebookStatus {
         }
     }
 }
+
+impl Serialize for NotebookStatus {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for NotebookStatus {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "published" => Self::PUBLISHED,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_notify_end_state.rs b/src/datadogV1/model/model_notify_end_state.rs
index 141e3d567..5cf333c22 100644
--- a/src/datadogV1/model/model_notify_end_state.rs
+++ b/src/datadogV1/model/model_notify_end_state.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum NotifyEndState {
-    #[serde(rename = "alert")]
     ALERT,
-    #[serde(rename = "no data")]
     NO_DATA,
-    #[serde(rename = "warn")]
     WARN,
 }
 
@@ -24,3 +21,34 @@ impl ToString for NotifyEndState {
         }
     }
 }
+
+impl Serialize for NotifyEndState {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for NotifyEndState {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "alert" => Self::ALERT,
+            "no data" => Self::NO_DATA,
+            "warn" => Self::WARN,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_notify_end_type.rs b/src/datadogV1/model/model_notify_end_type.rs
index f995dfc3d..79a8543a9 100644
--- a/src/datadogV1/model/model_notify_end_type.rs
+++ b/src/datadogV1/model/model_notify_end_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum NotifyEndType {
-    #[serde(rename = "canceled")]
     CANCELED,
-    #[serde(rename = "expired")]
     EXPIRED,
 }
 
@@ -21,3 +19,33 @@ impl ToString for NotifyEndType {
         }
     }
 }
+
+impl Serialize for NotifyEndType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for NotifyEndType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "canceled" => Self::CANCELED,
+            "expired" => Self::EXPIRED,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_on_missing_data_option.rs b/src/datadogV1/model/model_on_missing_data_option.rs
index 43a20532e..25eae60d6 100644
--- a/src/datadogV1/model/model_on_missing_data_option.rs
+++ b/src/datadogV1/model/model_on_missing_data_option.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum OnMissingDataOption {
-    #[serde(rename = "default")]
     DEFAULT,
-    #[serde(rename = "show_no_data")]
     SHOW_NO_DATA,
-    #[serde(rename = "show_and_notify_no_data")]
     SHOW_AND_NOTIFY_NO_DATA,
-    #[serde(rename = "resolve")]
     RESOLVE,
 }
 
@@ -27,3 +23,35 @@ impl ToString for OnMissingDataOption {
         }
     }
 }
+
+impl Serialize for OnMissingDataOption {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for OnMissingDataOption {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "default" => Self::DEFAULT,
+            "show_no_data" => Self::SHOW_NO_DATA,
+            "show_and_notify_no_data" => Self::SHOW_AND_NOTIFY_NO_DATA,
+            "resolve" => Self::RESOLVE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_powerpack_widget_definition_type.rs b/src/datadogV1/model/model_powerpack_widget_definition_type.rs
index fbd78986f..2e85f7cfc 100644
--- a/src/datadogV1/model/model_powerpack_widget_definition_type.rs
+++ b/src/datadogV1/model/model_powerpack_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum PowerpackWidgetDefinitionType {
-    #[serde(rename = "powerpack")]
     POWERPACK,
 }
 
@@ -18,3 +17,32 @@ impl ToString for PowerpackWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for PowerpackWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for PowerpackWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "powerpack" => Self::POWERPACK,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_query_sort_order.rs b/src/datadogV1/model/model_query_sort_order.rs
index 7d458d6f7..42f236175 100644
--- a/src/datadogV1/model/model_query_sort_order.rs
+++ b/src/datadogV1/model/model_query_sort_order.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum QuerySortOrder {
-    #[serde(rename = "asc")]
     ASC,
-    #[serde(rename = "desc")]
     DESC,
 }
 
@@ -21,3 +19,33 @@ impl ToString for QuerySortOrder {
         }
     }
 }
+
+impl Serialize for QuerySortOrder {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for QuerySortOrder {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "asc" => Self::ASC,
+            "desc" => Self::DESC,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_query_value_widget_definition_type.rs b/src/datadogV1/model/model_query_value_widget_definition_type.rs
index 2c483192d..ad0719543 100644
--- a/src/datadogV1/model/model_query_value_widget_definition_type.rs
+++ b/src/datadogV1/model/model_query_value_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum QueryValueWidgetDefinitionType {
-    #[serde(rename = "query_value")]
     QUERY_VALUE,
 }
 
@@ -18,3 +17,32 @@ impl ToString for QueryValueWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for QueryValueWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for QueryValueWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "query_value" => Self::QUERY_VALUE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_run_workflow_widget_definition_type.rs b/src/datadogV1/model/model_run_workflow_widget_definition_type.rs
index 59104cb25..b1a107b15 100644
--- a/src/datadogV1/model/model_run_workflow_widget_definition_type.rs
+++ b/src/datadogV1/model/model_run_workflow_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum RunWorkflowWidgetDefinitionType {
-    #[serde(rename = "run_workflow")]
     RUN_WORKFLOW,
 }
 
@@ -18,3 +17,32 @@ impl ToString for RunWorkflowWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for RunWorkflowWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for RunWorkflowWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "run_workflow" => Self::RUN_WORKFLOW,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_scatter_plot_widget_definition_type.rs b/src/datadogV1/model/model_scatter_plot_widget_definition_type.rs
index f1a07f15a..0fc658bbe 100644
--- a/src/datadogV1/model/model_scatter_plot_widget_definition_type.rs
+++ b/src/datadogV1/model/model_scatter_plot_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ScatterPlotWidgetDefinitionType {
-    #[serde(rename = "scatterplot")]
     SCATTERPLOT,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ScatterPlotWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for ScatterPlotWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ScatterPlotWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "scatterplot" => Self::SCATTERPLOT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_scatterplot_dimension.rs b/src/datadogV1/model/model_scatterplot_dimension.rs
index d280cc58d..e75c6fb0d 100644
--- a/src/datadogV1/model/model_scatterplot_dimension.rs
+++ b/src/datadogV1/model/model_scatterplot_dimension.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ScatterplotDimension {
-    #[serde(rename = "x")]
     X,
-    #[serde(rename = "y")]
     Y,
-    #[serde(rename = "radius")]
     RADIUS,
-    #[serde(rename = "color")]
     COLOR,
 }
 
@@ -27,3 +23,35 @@ impl ToString for ScatterplotDimension {
         }
     }
 }
+
+impl Serialize for ScatterplotDimension {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ScatterplotDimension {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "x" => Self::X,
+            "y" => Self::Y,
+            "radius" => Self::RADIUS,
+            "color" => Self::COLOR,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_scatterplot_widget_aggregator.rs b/src/datadogV1/model/model_scatterplot_widget_aggregator.rs
index f0a15bc46..25104ce6c 100644
--- a/src/datadogV1/model/model_scatterplot_widget_aggregator.rs
+++ b/src/datadogV1/model/model_scatterplot_widget_aggregator.rs
@@ -2,20 +2,15 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ScatterplotWidgetAggregator {
-    #[serde(rename = "avg")]
     AVERAGE,
-    #[serde(rename = "last")]
     LAST,
-    #[serde(rename = "max")]
     MAXIMUM,
-    #[serde(rename = "min")]
     MINIMUM,
-    #[serde(rename = "sum")]
     SUM,
 }
 
@@ -30,3 +25,36 @@ impl ToString for ScatterplotWidgetAggregator {
         }
     }
 }
+
+impl Serialize for ScatterplotWidgetAggregator {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ScatterplotWidgetAggregator {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "avg" => Self::AVERAGE,
+            "last" => Self::LAST,
+            "max" => Self::MAXIMUM,
+            "min" => Self::MINIMUM,
+            "sum" => Self::SUM,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_search_slo_timeframe.rs b/src/datadogV1/model/model_search_slo_timeframe.rs
index 8f6cadacb..8f363a6c6 100644
--- a/src/datadogV1/model/model_search_slo_timeframe.rs
+++ b/src/datadogV1/model/model_search_slo_timeframe.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SearchSLOTimeframe {
-    #[serde(rename = "7d")]
     SEVEN_DAYS,
-    #[serde(rename = "30d")]
     THIRTY_DAYS,
-    #[serde(rename = "90d")]
     NINETY_DAYS,
 }
 
@@ -24,3 +21,34 @@ impl ToString for SearchSLOTimeframe {
         }
     }
 }
+
+impl Serialize for SearchSLOTimeframe {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SearchSLOTimeframe {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "7d" => Self::SEVEN_DAYS,
+            "30d" => Self::THIRTY_DAYS,
+            "90d" => Self::NINETY_DAYS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_service_check_status.rs b/src/datadogV1/model/model_service_check_status.rs
index b23931e6e..a884ed054 100644
--- a/src/datadogV1/model/model_service_check_status.rs
+++ b/src/datadogV1/model/model_service_check_status.rs
@@ -2,27 +2,48 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde_repr::{Deserialize_repr, Serialize_repr};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(
-    Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize_repr, Deserialize_repr,
-)]
-#[repr(i32)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ServiceCheckStatus {
-    OK = 0,
-    WARNING = 1,
-    CRITICAL = 2,
-    UNKNOWN = 3,
+    OK,
+    WARNING,
+    CRITICAL,
+    UNKNOWN,
 }
 
-impl ToString for ServiceCheckStatus {
-    fn to_string(&self) -> String {
+impl Serialize for ServiceCheckStatus {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
         match self {
-            Self::OK => String::from("0"),
-            Self::WARNING => String::from("1"),
-            Self::CRITICAL => String::from("2"),
-            Self::UNKNOWN => String::from("3"),
+            Self::OK => serializer.serialize_i32(0),
+            Self::WARNING => serializer.serialize_i32(1),
+            Self::CRITICAL => serializer.serialize_i32(2),
+            Self::UNKNOWN => serializer.serialize_i32(3),
         }
     }
 }
+
+impl<'de> Deserialize<'de> for ServiceCheckStatus {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: i32 = i32::deserialize(deserializer)?;
+        Ok(match s {
+            0 => Self::OK,
+            1 => Self::WARNING,
+            2 => Self::CRITICAL,
+            3 => Self::UNKNOWN,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_service_map_widget_definition_type.rs b/src/datadogV1/model/model_service_map_widget_definition_type.rs
index b503b7df5..18597bebc 100644
--- a/src/datadogV1/model/model_service_map_widget_definition_type.rs
+++ b/src/datadogV1/model/model_service_map_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ServiceMapWidgetDefinitionType {
-    #[serde(rename = "servicemap")]
     SERVICEMAP,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ServiceMapWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for ServiceMapWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ServiceMapWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "servicemap" => Self::SERVICEMAP,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_service_summary_widget_definition_type.rs b/src/datadogV1/model/model_service_summary_widget_definition_type.rs
index ed12a8489..d2667b9fa 100644
--- a/src/datadogV1/model/model_service_summary_widget_definition_type.rs
+++ b/src/datadogV1/model/model_service_summary_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ServiceSummaryWidgetDefinitionType {
-    #[serde(rename = "trace_service")]
     TRACE_SERVICE,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ServiceSummaryWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for ServiceSummaryWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ServiceSummaryWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "trace_service" => Self::TRACE_SERVICE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_signal_archive_reason.rs b/src/datadogV1/model/model_signal_archive_reason.rs
index 7f629e6ad..5b82f68b8 100644
--- a/src/datadogV1/model/model_signal_archive_reason.rs
+++ b/src/datadogV1/model/model_signal_archive_reason.rs
@@ -2,20 +2,15 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SignalArchiveReason {
-    #[serde(rename = "none")]
     NONE,
-    #[serde(rename = "false_positive")]
     FALSE_POSITIVE,
-    #[serde(rename = "testing_or_maintenance")]
     TESTING_OR_MAINTENANCE,
-    #[serde(rename = "investigated_case_opened")]
     INVESTIGATED_CASE_OPENED,
-    #[serde(rename = "other")]
     OTHER,
 }
 
@@ -30,3 +25,36 @@ impl ToString for SignalArchiveReason {
         }
     }
 }
+
+impl Serialize for SignalArchiveReason {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SignalArchiveReason {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "none" => Self::NONE,
+            "false_positive" => Self::FALSE_POSITIVE,
+            "testing_or_maintenance" => Self::TESTING_OR_MAINTENANCE,
+            "investigated_case_opened" => Self::INVESTIGATED_CASE_OPENED,
+            "other" => Self::OTHER,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_signal_triage_state.rs b/src/datadogV1/model/model_signal_triage_state.rs
index 45fe2d9d8..298a357e9 100644
--- a/src/datadogV1/model/model_signal_triage_state.rs
+++ b/src/datadogV1/model/model_signal_triage_state.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SignalTriageState {
-    #[serde(rename = "open")]
     OPEN,
-    #[serde(rename = "archived")]
     ARCHIVED,
-    #[serde(rename = "under_review")]
     UNDER_REVIEW,
 }
 
@@ -24,3 +21,34 @@ impl ToString for SignalTriageState {
         }
     }
 }
+
+impl Serialize for SignalTriageState {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SignalTriageState {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "open" => Self::OPEN,
+            "archived" => Self::ARCHIVED,
+            "under_review" => Self::UNDER_REVIEW,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_slo_correction_category.rs b/src/datadogV1/model/model_slo_correction_category.rs
index 41b6113d8..de6e0cc70 100644
--- a/src/datadogV1/model/model_slo_correction_category.rs
+++ b/src/datadogV1/model/model_slo_correction_category.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SLOCorrectionCategory {
-    #[serde(rename = "Scheduled Maintenance")]
     SCHEDULED_MAINTENANCE,
-    #[serde(rename = "Outside Business Hours")]
     OUTSIDE_BUSINESS_HOURS,
-    #[serde(rename = "Deployment")]
     DEPLOYMENT,
-    #[serde(rename = "Other")]
     OTHER,
 }
 
@@ -27,3 +23,35 @@ impl ToString for SLOCorrectionCategory {
         }
     }
 }
+
+impl Serialize for SLOCorrectionCategory {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SLOCorrectionCategory {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "Scheduled Maintenance" => Self::SCHEDULED_MAINTENANCE,
+            "Outside Business Hours" => Self::OUTSIDE_BUSINESS_HOURS,
+            "Deployment" => Self::DEPLOYMENT,
+            "Other" => Self::OTHER,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_slo_correction_type.rs b/src/datadogV1/model/model_slo_correction_type.rs
index 6ab09e30c..a523f09a0 100644
--- a/src/datadogV1/model/model_slo_correction_type.rs
+++ b/src/datadogV1/model/model_slo_correction_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SLOCorrectionType {
-    #[serde(rename = "correction")]
     CORRECTION,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SLOCorrectionType {
         }
     }
 }
+
+impl Serialize for SLOCorrectionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SLOCorrectionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "correction" => Self::CORRECTION,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_slo_error_timeframe.rs b/src/datadogV1/model/model_slo_error_timeframe.rs
index 924bee968..8fcded222 100644
--- a/src/datadogV1/model/model_slo_error_timeframe.rs
+++ b/src/datadogV1/model/model_slo_error_timeframe.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SLOErrorTimeframe {
-    #[serde(rename = "7d")]
     SEVEN_DAYS,
-    #[serde(rename = "30d")]
     THIRTY_DAYS,
-    #[serde(rename = "90d")]
     NINETY_DAYS,
-    #[serde(rename = "all")]
     ALL,
 }
 
@@ -27,3 +23,35 @@ impl ToString for SLOErrorTimeframe {
         }
     }
 }
+
+impl Serialize for SLOErrorTimeframe {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SLOErrorTimeframe {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "7d" => Self::SEVEN_DAYS,
+            "30d" => Self::THIRTY_DAYS,
+            "90d" => Self::NINETY_DAYS,
+            "all" => Self::ALL,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_slo_list_widget_definition_type.rs b/src/datadogV1/model/model_slo_list_widget_definition_type.rs
index 6ae7fa77d..dc0ddfe6e 100644
--- a/src/datadogV1/model/model_slo_list_widget_definition_type.rs
+++ b/src/datadogV1/model/model_slo_list_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SLOListWidgetDefinitionType {
-    #[serde(rename = "slo_list")]
     SLO_LIST,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SLOListWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for SLOListWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SLOListWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "slo_list" => Self::SLO_LIST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_slo_list_widget_request_type.rs b/src/datadogV1/model/model_slo_list_widget_request_type.rs
index 703cf9730..2e0a1e5b1 100644
--- a/src/datadogV1/model/model_slo_list_widget_request_type.rs
+++ b/src/datadogV1/model/model_slo_list_widget_request_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SLOListWidgetRequestType {
-    #[serde(rename = "slo_list")]
     SLO_LIST,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SLOListWidgetRequestType {
         }
     }
 }
+
+impl Serialize for SLOListWidgetRequestType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SLOListWidgetRequestType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "slo_list" => Self::SLO_LIST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_slo_state.rs b/src/datadogV1/model/model_slo_state.rs
index 876ee95e9..6debf6548 100644
--- a/src/datadogV1/model/model_slo_state.rs
+++ b/src/datadogV1/model/model_slo_state.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SLOState {
-    #[serde(rename = "breached")]
     BREACHED,
-    #[serde(rename = "warning")]
     WARNING,
-    #[serde(rename = "ok")]
     OK,
-    #[serde(rename = "no_data")]
     NO_DATA,
 }
 
@@ -27,3 +23,35 @@ impl ToString for SLOState {
         }
     }
 }
+
+impl Serialize for SLOState {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SLOState {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "breached" => Self::BREACHED,
+            "warning" => Self::WARNING,
+            "ok" => Self::OK,
+            "no_data" => Self::NO_DATA,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_slo_timeframe.rs b/src/datadogV1/model/model_slo_timeframe.rs
index 5c882332f..f2be45aff 100644
--- a/src/datadogV1/model/model_slo_timeframe.rs
+++ b/src/datadogV1/model/model_slo_timeframe.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SLOTimeframe {
-    #[serde(rename = "7d")]
     SEVEN_DAYS,
-    #[serde(rename = "30d")]
     THIRTY_DAYS,
-    #[serde(rename = "90d")]
     NINETY_DAYS,
-    #[serde(rename = "custom")]
     CUSTOM,
 }
 
@@ -27,3 +23,35 @@ impl ToString for SLOTimeframe {
         }
     }
 }
+
+impl Serialize for SLOTimeframe {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SLOTimeframe {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "7d" => Self::SEVEN_DAYS,
+            "30d" => Self::THIRTY_DAYS,
+            "90d" => Self::NINETY_DAYS,
+            "custom" => Self::CUSTOM,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_slo_type.rs b/src/datadogV1/model/model_slo_type.rs
index 481ced4f1..8ee88bc41 100644
--- a/src/datadogV1/model/model_slo_type.rs
+++ b/src/datadogV1/model/model_slo_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SLOType {
-    #[serde(rename = "metric")]
     METRIC,
-    #[serde(rename = "monitor")]
     MONITOR,
 }
 
@@ -21,3 +19,33 @@ impl ToString for SLOType {
         }
     }
 }
+
+impl Serialize for SLOType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SLOType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "metric" => Self::METRIC,
+            "monitor" => Self::MONITOR,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_slo_type_numeric.rs b/src/datadogV1/model/model_slo_type_numeric.rs
index 011eb19b2..05ce9f6f8 100644
--- a/src/datadogV1/model/model_slo_type_numeric.rs
+++ b/src/datadogV1/model/model_slo_type_numeric.rs
@@ -2,23 +2,42 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde_repr::{Deserialize_repr, Serialize_repr};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(
-    Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize_repr, Deserialize_repr,
-)]
-#[repr(i32)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SLOTypeNumeric {
-    MONITOR = 0,
-    METRIC = 1,
+    MONITOR,
+    METRIC,
 }
 
-impl ToString for SLOTypeNumeric {
-    fn to_string(&self) -> String {
+impl Serialize for SLOTypeNumeric {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
         match self {
-            Self::MONITOR => String::from("0"),
-            Self::METRIC => String::from("1"),
+            Self::MONITOR => serializer.serialize_i32(0),
+            Self::METRIC => serializer.serialize_i32(1),
         }
     }
 }
+
+impl<'de> Deserialize<'de> for SLOTypeNumeric {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: i32 = i32::deserialize(deserializer)?;
+        Ok(match s {
+            0 => Self::MONITOR,
+            1 => Self::METRIC,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_slo_widget_definition_type.rs b/src/datadogV1/model/model_slo_widget_definition_type.rs
index 6787b5b97..defff925e 100644
--- a/src/datadogV1/model/model_slo_widget_definition_type.rs
+++ b/src/datadogV1/model/model_slo_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SLOWidgetDefinitionType {
-    #[serde(rename = "slo")]
     SLO,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SLOWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for SLOWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SLOWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "slo" => Self::SLO,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_split_graph_viz_size.rs b/src/datadogV1/model/model_split_graph_viz_size.rs
index 23bcb84f6..2d0ee133c 100644
--- a/src/datadogV1/model/model_split_graph_viz_size.rs
+++ b/src/datadogV1/model/model_split_graph_viz_size.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SplitGraphVizSize {
-    #[serde(rename = "xs")]
     XS,
-    #[serde(rename = "sm")]
     SM,
-    #[serde(rename = "md")]
     MD,
-    #[serde(rename = "lg")]
     LG,
 }
 
@@ -27,3 +23,35 @@ impl ToString for SplitGraphVizSize {
         }
     }
 }
+
+impl Serialize for SplitGraphVizSize {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SplitGraphVizSize {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "xs" => Self::XS,
+            "sm" => Self::SM,
+            "md" => Self::MD,
+            "lg" => Self::LG,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_split_graph_widget_definition_type.rs b/src/datadogV1/model/model_split_graph_widget_definition_type.rs
index 31aae3d13..7ab49734b 100644
--- a/src/datadogV1/model/model_split_graph_widget_definition_type.rs
+++ b/src/datadogV1/model/model_split_graph_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SplitGraphWidgetDefinitionType {
-    #[serde(rename = "split_group")]
     SPLIT_GROUP,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SplitGraphWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for SplitGraphWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SplitGraphWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "split_group" => Self::SPLIT_GROUP,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_sunburst_widget_definition_type.rs b/src/datadogV1/model/model_sunburst_widget_definition_type.rs
index bf013f1ca..fb83439df 100644
--- a/src/datadogV1/model/model_sunburst_widget_definition_type.rs
+++ b/src/datadogV1/model/model_sunburst_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SunburstWidgetDefinitionType {
-    #[serde(rename = "sunburst")]
     SUNBURST,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SunburstWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for SunburstWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SunburstWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "sunburst" => Self::SUNBURST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_sunburst_widget_legend_inline_automatic_type.rs b/src/datadogV1/model/model_sunburst_widget_legend_inline_automatic_type.rs
index c565afb71..40a65a29b 100644
--- a/src/datadogV1/model/model_sunburst_widget_legend_inline_automatic_type.rs
+++ b/src/datadogV1/model/model_sunburst_widget_legend_inline_automatic_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SunburstWidgetLegendInlineAutomaticType {
-    #[serde(rename = "inline")]
     INLINE,
-    #[serde(rename = "automatic")]
     AUTOMATIC,
 }
 
@@ -21,3 +19,33 @@ impl ToString for SunburstWidgetLegendInlineAutomaticType {
         }
     }
 }
+
+impl Serialize for SunburstWidgetLegendInlineAutomaticType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SunburstWidgetLegendInlineAutomaticType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "inline" => Self::INLINE,
+            "automatic" => Self::AUTOMATIC,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_sunburst_widget_legend_table_type.rs b/src/datadogV1/model/model_sunburst_widget_legend_table_type.rs
index b01430500..e974f0685 100644
--- a/src/datadogV1/model/model_sunburst_widget_legend_table_type.rs
+++ b/src/datadogV1/model/model_sunburst_widget_legend_table_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SunburstWidgetLegendTableType {
-    #[serde(rename = "table")]
     TABLE,
-    #[serde(rename = "none")]
     NONE,
 }
 
@@ -21,3 +19,33 @@ impl ToString for SunburstWidgetLegendTableType {
         }
     }
 }
+
+impl Serialize for SunburstWidgetLegendTableType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SunburstWidgetLegendTableType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "table" => Self::TABLE,
+            "none" => Self::NONE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_api_step_subtype.rs b/src/datadogV1/model/model_synthetics_api_step_subtype.rs
index cc600648a..76d22c409 100644
--- a/src/datadogV1/model/model_synthetics_api_step_subtype.rs
+++ b/src/datadogV1/model/model_synthetics_api_step_subtype.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsAPIStepSubtype {
-    #[serde(rename = "http")]
     HTTP,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SyntheticsAPIStepSubtype {
         }
     }
 }
+
+impl Serialize for SyntheticsAPIStepSubtype {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsAPIStepSubtype {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "http" => Self::HTTP,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_api_test_failure_code.rs b/src/datadogV1/model/model_synthetics_api_test_failure_code.rs
index 8a77672e7..6e488525f 100644
--- a/src/datadogV1/model/model_synthetics_api_test_failure_code.rs
+++ b/src/datadogV1/model/model_synthetics_api_test_failure_code.rs
@@ -2,62 +2,36 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsApiTestFailureCode {
-    #[serde(rename = "BODY_TOO_LARGE")]
     BODY_TOO_LARGE,
-    #[serde(rename = "DENIED")]
     DENIED,
-    #[serde(rename = "TOO_MANY_REDIRECTS")]
     TOO_MANY_REDIRECTS,
-    #[serde(rename = "AUTHENTICATION_ERROR")]
     AUTHENTICATION_ERROR,
-    #[serde(rename = "DECRYPTION")]
     DECRYPTION,
-    #[serde(rename = "INVALID_CHAR_IN_HEADER")]
     INVALID_CHAR_IN_HEADER,
-    #[serde(rename = "HEADER_TOO_LARGE")]
     HEADER_TOO_LARGE,
-    #[serde(rename = "HEADERS_INCOMPATIBLE_CONTENT_LENGTH")]
     HEADERS_INCOMPATIBLE_CONTENT_LENGTH,
-    #[serde(rename = "INVALID_REQUEST")]
     INVALID_REQUEST,
-    #[serde(rename = "REQUIRES_UPDATE")]
     REQUIRES_UPDATE,
-    #[serde(rename = "UNESCAPED_CHARACTERS_IN_REQUEST_PATH")]
     UNESCAPED_CHARACTERS_IN_REQUEST_PATH,
-    #[serde(rename = "MALFORMED_RESPONSE")]
     MALFORMED_RESPONSE,
-    #[serde(rename = "INCORRECT_ASSERTION")]
     INCORRECT_ASSERTION,
-    #[serde(rename = "CONNREFUSED")]
     CONNREFUSED,
-    #[serde(rename = "CONNRESET")]
     CONNRESET,
-    #[serde(rename = "DNS")]
     DNS,
-    #[serde(rename = "HOSTUNREACH")]
     HOSTUNREACH,
-    #[serde(rename = "NETUNREACH")]
     NETUNREACH,
-    #[serde(rename = "TIMEOUT")]
     TIMEOUT,
-    #[serde(rename = "SSL")]
     SSL,
-    #[serde(rename = "OCSP")]
     OCSP,
-    #[serde(rename = "INVALID_TEST")]
     INVALID_TEST,
-    #[serde(rename = "TUNNEL")]
     TUNNEL,
-    #[serde(rename = "WEBSOCKET")]
     WEBSOCKET,
-    #[serde(rename = "UNKNOWN")]
     UNKNOWN,
-    #[serde(rename = "INTERNAL_ERROR")]
     INTERNAL_ERROR,
 }
 
@@ -97,3 +71,57 @@ impl ToString for SyntheticsApiTestFailureCode {
         }
     }
 }
+
+impl Serialize for SyntheticsApiTestFailureCode {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsApiTestFailureCode {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "BODY_TOO_LARGE" => Self::BODY_TOO_LARGE,
+            "DENIED" => Self::DENIED,
+            "TOO_MANY_REDIRECTS" => Self::TOO_MANY_REDIRECTS,
+            "AUTHENTICATION_ERROR" => Self::AUTHENTICATION_ERROR,
+            "DECRYPTION" => Self::DECRYPTION,
+            "INVALID_CHAR_IN_HEADER" => Self::INVALID_CHAR_IN_HEADER,
+            "HEADER_TOO_LARGE" => Self::HEADER_TOO_LARGE,
+            "HEADERS_INCOMPATIBLE_CONTENT_LENGTH" => Self::HEADERS_INCOMPATIBLE_CONTENT_LENGTH,
+            "INVALID_REQUEST" => Self::INVALID_REQUEST,
+            "REQUIRES_UPDATE" => Self::REQUIRES_UPDATE,
+            "UNESCAPED_CHARACTERS_IN_REQUEST_PATH" => Self::UNESCAPED_CHARACTERS_IN_REQUEST_PATH,
+            "MALFORMED_RESPONSE" => Self::MALFORMED_RESPONSE,
+            "INCORRECT_ASSERTION" => Self::INCORRECT_ASSERTION,
+            "CONNREFUSED" => Self::CONNREFUSED,
+            "CONNRESET" => Self::CONNRESET,
+            "DNS" => Self::DNS,
+            "HOSTUNREACH" => Self::HOSTUNREACH,
+            "NETUNREACH" => Self::NETUNREACH,
+            "TIMEOUT" => Self::TIMEOUT,
+            "SSL" => Self::SSL,
+            "OCSP" => Self::OCSP,
+            "INVALID_TEST" => Self::INVALID_TEST,
+            "TUNNEL" => Self::TUNNEL,
+            "WEBSOCKET" => Self::WEBSOCKET,
+            "UNKNOWN" => Self::UNKNOWN,
+            "INTERNAL_ERROR" => Self::INTERNAL_ERROR,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_api_test_type.rs b/src/datadogV1/model/model_synthetics_api_test_type.rs
index 79dbdf277..36af0700e 100644
--- a/src/datadogV1/model/model_synthetics_api_test_type.rs
+++ b/src/datadogV1/model/model_synthetics_api_test_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsAPITestType {
-    #[serde(rename = "api")]
     API,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SyntheticsAPITestType {
         }
     }
 }
+
+impl Serialize for SyntheticsAPITestType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsAPITestType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "api" => Self::API,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_assertion_json_path_operator.rs b/src/datadogV1/model/model_synthetics_assertion_json_path_operator.rs
index f2154ba85..bbf3c8343 100644
--- a/src/datadogV1/model/model_synthetics_assertion_json_path_operator.rs
+++ b/src/datadogV1/model/model_synthetics_assertion_json_path_operator.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsAssertionJSONPathOperator {
-    #[serde(rename = "validatesJSONPath")]
     VALIDATES_JSON_PATH,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SyntheticsAssertionJSONPathOperator {
         }
     }
 }
+
+impl Serialize for SyntheticsAssertionJSONPathOperator {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsAssertionJSONPathOperator {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "validatesJSONPath" => Self::VALIDATES_JSON_PATH,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_assertion_operator.rs b/src/datadogV1/model/model_synthetics_assertion_operator.rs
index 9a5508f54..b4412f588 100644
--- a/src/datadogV1/model/model_synthetics_assertion_operator.rs
+++ b/src/datadogV1/model/model_synthetics_assertion_operator.rs
@@ -2,40 +2,25 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsAssertionOperator {
-    #[serde(rename = "contains")]
     CONTAINS,
-    #[serde(rename = "doesNotContain")]
     DOES_NOT_CONTAIN,
-    #[serde(rename = "is")]
     IS,
-    #[serde(rename = "isNot")]
     IS_NOT,
-    #[serde(rename = "lessThan")]
     LESS_THAN,
-    #[serde(rename = "lessThanOrEqual")]
     LESS_THAN_OR_EQUAL,
-    #[serde(rename = "moreThan")]
     MORE_THAN,
-    #[serde(rename = "moreThanOrEqual")]
     MORE_THAN_OR_EQUAL,
-    #[serde(rename = "matches")]
     MATCHES,
-    #[serde(rename = "doesNotMatch")]
     DOES_NOT_MATCH,
-    #[serde(rename = "validates")]
     VALIDATES,
-    #[serde(rename = "isInMoreThan")]
     IS_IN_MORE_DAYS_THAN,
-    #[serde(rename = "isInLessThan")]
     IS_IN_LESS_DAYS_THAN,
-    #[serde(rename = "doesNotExist")]
     DOES_NOT_EXIST,
-    #[serde(rename = "isUndefined")]
     IS_UNDEFINED,
 }
 
@@ -60,3 +45,46 @@ impl ToString for SyntheticsAssertionOperator {
         }
     }
 }
+
+impl Serialize for SyntheticsAssertionOperator {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsAssertionOperator {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "contains" => Self::CONTAINS,
+            "doesNotContain" => Self::DOES_NOT_CONTAIN,
+            "is" => Self::IS,
+            "isNot" => Self::IS_NOT,
+            "lessThan" => Self::LESS_THAN,
+            "lessThanOrEqual" => Self::LESS_THAN_OR_EQUAL,
+            "moreThan" => Self::MORE_THAN,
+            "moreThanOrEqual" => Self::MORE_THAN_OR_EQUAL,
+            "matches" => Self::MATCHES,
+            "doesNotMatch" => Self::DOES_NOT_MATCH,
+            "validates" => Self::VALIDATES,
+            "isInMoreThan" => Self::IS_IN_MORE_DAYS_THAN,
+            "isInLessThan" => Self::IS_IN_LESS_DAYS_THAN,
+            "doesNotExist" => Self::DOES_NOT_EXIST,
+            "isUndefined" => Self::IS_UNDEFINED,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_assertion_timings_scope.rs b/src/datadogV1/model/model_synthetics_assertion_timings_scope.rs
index 7c8ce6fbd..6ae891d99 100644
--- a/src/datadogV1/model/model_synthetics_assertion_timings_scope.rs
+++ b/src/datadogV1/model/model_synthetics_assertion_timings_scope.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsAssertionTimingsScope {
-    #[serde(rename = "all")]
     ALL,
-    #[serde(rename = "withoutDNS")]
     WITHOUT_DNS,
 }
 
@@ -21,3 +19,33 @@ impl ToString for SyntheticsAssertionTimingsScope {
         }
     }
 }
+
+impl Serialize for SyntheticsAssertionTimingsScope {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsAssertionTimingsScope {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "all" => Self::ALL,
+            "withoutDNS" => Self::WITHOUT_DNS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_assertion_type.rs b/src/datadogV1/model/model_synthetics_assertion_type.rs
index cb5cf9cea..9ffb17885 100644
--- a/src/datadogV1/model/model_synthetics_assertion_type.rs
+++ b/src/datadogV1/model/model_synthetics_assertion_type.rs
@@ -2,48 +2,29 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsAssertionType {
-    #[serde(rename = "body")]
     BODY,
-    #[serde(rename = "header")]
     HEADER,
-    #[serde(rename = "statusCode")]
     STATUS_CODE,
-    #[serde(rename = "certificate")]
     CERTIFICATE,
-    #[serde(rename = "responseTime")]
     RESPONSE_TIME,
-    #[serde(rename = "property")]
     PROPERTY,
-    #[serde(rename = "recordEvery")]
     RECORD_EVERY,
-    #[serde(rename = "recordSome")]
     RECORD_SOME,
-    #[serde(rename = "tlsVersion")]
     TLS_VERSION,
-    #[serde(rename = "minTlsVersion")]
     MIN_TLS_VERSION,
-    #[serde(rename = "latency")]
     LATENCY,
-    #[serde(rename = "packetLossPercentage")]
     PACKET_LOSS_PERCENTAGE,
-    #[serde(rename = "packetsReceived")]
     PACKETS_RECEIVED,
-    #[serde(rename = "networkHop")]
     NETWORK_HOP,
-    #[serde(rename = "receivedMessage")]
     RECEIVED_MESSAGE,
-    #[serde(rename = "grpcHealthcheckStatus")]
     GRPC_HEALTHCHECK_STATUS,
-    #[serde(rename = "grpcMetadata")]
     GRPC_METADATA,
-    #[serde(rename = "grpcProto")]
     GRPC_PROTO,
-    #[serde(rename = "connection")]
     CONNECTION,
 }
 
@@ -72,3 +53,50 @@ impl ToString for SyntheticsAssertionType {
         }
     }
 }
+
+impl Serialize for SyntheticsAssertionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsAssertionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "body" => Self::BODY,
+            "header" => Self::HEADER,
+            "statusCode" => Self::STATUS_CODE,
+            "certificate" => Self::CERTIFICATE,
+            "responseTime" => Self::RESPONSE_TIME,
+            "property" => Self::PROPERTY,
+            "recordEvery" => Self::RECORD_EVERY,
+            "recordSome" => Self::RECORD_SOME,
+            "tlsVersion" => Self::TLS_VERSION,
+            "minTlsVersion" => Self::MIN_TLS_VERSION,
+            "latency" => Self::LATENCY,
+            "packetLossPercentage" => Self::PACKET_LOSS_PERCENTAGE,
+            "packetsReceived" => Self::PACKETS_RECEIVED,
+            "networkHop" => Self::NETWORK_HOP,
+            "receivedMessage" => Self::RECEIVED_MESSAGE,
+            "grpcHealthcheckStatus" => Self::GRPC_HEALTHCHECK_STATUS,
+            "grpcMetadata" => Self::GRPC_METADATA,
+            "grpcProto" => Self::GRPC_PROTO,
+            "connection" => Self::CONNECTION,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_assertion_x_path_operator.rs b/src/datadogV1/model/model_synthetics_assertion_x_path_operator.rs
index e3b4d6e2b..629abf8af 100644
--- a/src/datadogV1/model/model_synthetics_assertion_x_path_operator.rs
+++ b/src/datadogV1/model/model_synthetics_assertion_x_path_operator.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsAssertionXPathOperator {
-    #[serde(rename = "validatesXPath")]
     VALIDATES_X_PATH,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SyntheticsAssertionXPathOperator {
         }
     }
 }
+
+impl Serialize for SyntheticsAssertionXPathOperator {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsAssertionXPathOperator {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "validatesXPath" => Self::VALIDATES_X_PATH,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_basic_auth_digest_type.rs b/src/datadogV1/model/model_synthetics_basic_auth_digest_type.rs
index bd008ebc1..2051a5d1b 100644
--- a/src/datadogV1/model/model_synthetics_basic_auth_digest_type.rs
+++ b/src/datadogV1/model/model_synthetics_basic_auth_digest_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsBasicAuthDigestType {
-    #[serde(rename = "digest")]
     DIGEST,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SyntheticsBasicAuthDigestType {
         }
     }
 }
+
+impl Serialize for SyntheticsBasicAuthDigestType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsBasicAuthDigestType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "digest" => Self::DIGEST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_basic_auth_ntlm_type.rs b/src/datadogV1/model/model_synthetics_basic_auth_ntlm_type.rs
index dd0d33b92..5321ccf9e 100644
--- a/src/datadogV1/model/model_synthetics_basic_auth_ntlm_type.rs
+++ b/src/datadogV1/model/model_synthetics_basic_auth_ntlm_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsBasicAuthNTLMType {
-    #[serde(rename = "ntlm")]
     NTLM,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SyntheticsBasicAuthNTLMType {
         }
     }
 }
+
+impl Serialize for SyntheticsBasicAuthNTLMType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsBasicAuthNTLMType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "ntlm" => Self::NTLM,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_basic_auth_oauth_client_type.rs b/src/datadogV1/model/model_synthetics_basic_auth_oauth_client_type.rs
index 561a952a8..f6829a73e 100644
--- a/src/datadogV1/model/model_synthetics_basic_auth_oauth_client_type.rs
+++ b/src/datadogV1/model/model_synthetics_basic_auth_oauth_client_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsBasicAuthOauthClientType {
-    #[serde(rename = "oauth-client")]
     OAUTH_CLIENT,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SyntheticsBasicAuthOauthClientType {
         }
     }
 }
+
+impl Serialize for SyntheticsBasicAuthOauthClientType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsBasicAuthOauthClientType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "oauth-client" => Self::OAUTH_CLIENT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_basic_auth_oauth_rop_type.rs b/src/datadogV1/model/model_synthetics_basic_auth_oauth_rop_type.rs
index f626ad42c..90df3674a 100644
--- a/src/datadogV1/model/model_synthetics_basic_auth_oauth_rop_type.rs
+++ b/src/datadogV1/model/model_synthetics_basic_auth_oauth_rop_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsBasicAuthOauthROPType {
-    #[serde(rename = "oauth-rop")]
     OAUTH_ROP,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SyntheticsBasicAuthOauthROPType {
         }
     }
 }
+
+impl Serialize for SyntheticsBasicAuthOauthROPType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsBasicAuthOauthROPType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "oauth-rop" => Self::OAUTH_ROP,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_basic_auth_oauth_token_api_authentication.rs b/src/datadogV1/model/model_synthetics_basic_auth_oauth_token_api_authentication.rs
index a370123a1..52d77feb9 100644
--- a/src/datadogV1/model/model_synthetics_basic_auth_oauth_token_api_authentication.rs
+++ b/src/datadogV1/model/model_synthetics_basic_auth_oauth_token_api_authentication.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsBasicAuthOauthTokenApiAuthentication {
-    #[serde(rename = "header")]
     HEADER,
-    #[serde(rename = "body")]
     BODY,
 }
 
@@ -21,3 +19,33 @@ impl ToString for SyntheticsBasicAuthOauthTokenApiAuthentication {
         }
     }
 }
+
+impl Serialize for SyntheticsBasicAuthOauthTokenApiAuthentication {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsBasicAuthOauthTokenApiAuthentication {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "header" => Self::HEADER,
+            "body" => Self::BODY,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_basic_auth_sigv4_type.rs b/src/datadogV1/model/model_synthetics_basic_auth_sigv4_type.rs
index bafa36177..accc297e1 100644
--- a/src/datadogV1/model/model_synthetics_basic_auth_sigv4_type.rs
+++ b/src/datadogV1/model/model_synthetics_basic_auth_sigv4_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsBasicAuthSigv4Type {
-    #[serde(rename = "sigv4")]
     SIGV4,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SyntheticsBasicAuthSigv4Type {
         }
     }
 }
+
+impl Serialize for SyntheticsBasicAuthSigv4Type {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsBasicAuthSigv4Type {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "sigv4" => Self::SIGV4,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_basic_auth_web_type.rs b/src/datadogV1/model/model_synthetics_basic_auth_web_type.rs
index e604eab29..0b9ce51cb 100644
--- a/src/datadogV1/model/model_synthetics_basic_auth_web_type.rs
+++ b/src/datadogV1/model/model_synthetics_basic_auth_web_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsBasicAuthWebType {
-    #[serde(rename = "web")]
     WEB,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SyntheticsBasicAuthWebType {
         }
     }
 }
+
+impl Serialize for SyntheticsBasicAuthWebType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsBasicAuthWebType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "web" => Self::WEB,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_browser_error_type.rs b/src/datadogV1/model/model_synthetics_browser_error_type.rs
index 2d5ad3ce6..5733c088f 100644
--- a/src/datadogV1/model/model_synthetics_browser_error_type.rs
+++ b/src/datadogV1/model/model_synthetics_browser_error_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsBrowserErrorType {
-    #[serde(rename = "network")]
     NETWORK,
-    #[serde(rename = "js")]
     JS,
 }
 
@@ -21,3 +19,33 @@ impl ToString for SyntheticsBrowserErrorType {
         }
     }
 }
+
+impl Serialize for SyntheticsBrowserErrorType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsBrowserErrorType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "network" => Self::NETWORK,
+            "js" => Self::JS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_browser_test_failure_code.rs b/src/datadogV1/model/model_synthetics_browser_test_failure_code.rs
index bf5a8841f..db62d5ab2 100644
--- a/src/datadogV1/model/model_synthetics_browser_test_failure_code.rs
+++ b/src/datadogV1/model/model_synthetics_browser_test_failure_code.rs
@@ -2,76 +2,43 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsBrowserTestFailureCode {
-    #[serde(rename = "API_REQUEST_FAILURE")]
     API_REQUEST_FAILURE,
-    #[serde(rename = "ASSERTION_FAILURE")]
     ASSERTION_FAILURE,
-    #[serde(rename = "DOWNLOAD_FILE_TOO_LARGE")]
     DOWNLOAD_FILE_TOO_LARGE,
-    #[serde(rename = "ELEMENT_NOT_INTERACTABLE")]
     ELEMENT_NOT_INTERACTABLE,
-    #[serde(rename = "EMAIL_VARIABLE_NOT_DEFINED")]
     EMAIL_VARIABLE_NOT_DEFINED,
-    #[serde(rename = "EVALUATE_JAVASCRIPT")]
     EVALUATE_JAVASCRIPT,
-    #[serde(rename = "EVALUATE_JAVASCRIPT_CONTEXT")]
     EVALUATE_JAVASCRIPT_CONTEXT,
-    #[serde(rename = "EXTRACT_VARIABLE")]
     EXTRACT_VARIABLE,
-    #[serde(rename = "FORBIDDEN_URL")]
     FORBIDDEN_URL,
-    #[serde(rename = "FRAME_DETACHED")]
     FRAME_DETACHED,
-    #[serde(rename = "INCONSISTENCIES")]
     INCONSISTENCIES,
-    #[serde(rename = "INTERNAL_ERROR")]
     INTERNAL_ERROR,
-    #[serde(rename = "INVALID_TYPE_TEXT_DELAY")]
     INVALID_TYPE_TEXT_DELAY,
-    #[serde(rename = "INVALID_URL")]
     INVALID_URL,
-    #[serde(rename = "INVALID_VARIABLE_PATTERN")]
     INVALID_VARIABLE_PATTERN,
-    #[serde(rename = "INVISIBLE_ELEMENT")]
     INVISIBLE_ELEMENT,
-    #[serde(rename = "LOCATE_ELEMENT")]
     LOCATE_ELEMENT,
-    #[serde(rename = "NAVIGATE_TO_LINK")]
     NAVIGATE_TO_LINK,
-    #[serde(rename = "OPEN_URL")]
     OPEN_URL,
-    #[serde(rename = "PRESS_KEY")]
     PRESS_KEY,
-    #[serde(rename = "SERVER_CERTIFICATE")]
     SERVER_CERTIFICATE,
-    #[serde(rename = "SELECT_OPTION")]
     SELECT_OPTION,
-    #[serde(rename = "STEP_TIMEOUT")]
     STEP_TIMEOUT,
-    #[serde(rename = "SUB_TEST_NOT_PASSED")]
     SUB_TEST_NOT_PASSED,
-    #[serde(rename = "TEST_TIMEOUT")]
     TEST_TIMEOUT,
-    #[serde(rename = "TOO_MANY_HTTP_REQUESTS")]
     TOO_MANY_HTTP_REQUESTS,
-    #[serde(rename = "UNAVAILABLE_BROWSER")]
     UNAVAILABLE_BROWSER,
-    #[serde(rename = "UNKNOWN")]
     UNKNOWN,
-    #[serde(rename = "UNSUPPORTED_AUTH_SCHEMA")]
     UNSUPPORTED_AUTH_SCHEMA,
-    #[serde(rename = "UPLOAD_FILES_ELEMENT_TYPE")]
     UPLOAD_FILES_ELEMENT_TYPE,
-    #[serde(rename = "UPLOAD_FILES_DIALOG")]
     UPLOAD_FILES_DIALOG,
-    #[serde(rename = "UPLOAD_FILES_DYNAMIC_ELEMENT")]
     UPLOAD_FILES_DYNAMIC_ELEMENT,
-    #[serde(rename = "UPLOAD_FILES_NAME")]
     UPLOAD_FILES_NAME,
 }
 
@@ -114,3 +81,64 @@ impl ToString for SyntheticsBrowserTestFailureCode {
         }
     }
 }
+
+impl Serialize for SyntheticsBrowserTestFailureCode {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsBrowserTestFailureCode {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "API_REQUEST_FAILURE" => Self::API_REQUEST_FAILURE,
+            "ASSERTION_FAILURE" => Self::ASSERTION_FAILURE,
+            "DOWNLOAD_FILE_TOO_LARGE" => Self::DOWNLOAD_FILE_TOO_LARGE,
+            "ELEMENT_NOT_INTERACTABLE" => Self::ELEMENT_NOT_INTERACTABLE,
+            "EMAIL_VARIABLE_NOT_DEFINED" => Self::EMAIL_VARIABLE_NOT_DEFINED,
+            "EVALUATE_JAVASCRIPT" => Self::EVALUATE_JAVASCRIPT,
+            "EVALUATE_JAVASCRIPT_CONTEXT" => Self::EVALUATE_JAVASCRIPT_CONTEXT,
+            "EXTRACT_VARIABLE" => Self::EXTRACT_VARIABLE,
+            "FORBIDDEN_URL" => Self::FORBIDDEN_URL,
+            "FRAME_DETACHED" => Self::FRAME_DETACHED,
+            "INCONSISTENCIES" => Self::INCONSISTENCIES,
+            "INTERNAL_ERROR" => Self::INTERNAL_ERROR,
+            "INVALID_TYPE_TEXT_DELAY" => Self::INVALID_TYPE_TEXT_DELAY,
+            "INVALID_URL" => Self::INVALID_URL,
+            "INVALID_VARIABLE_PATTERN" => Self::INVALID_VARIABLE_PATTERN,
+            "INVISIBLE_ELEMENT" => Self::INVISIBLE_ELEMENT,
+            "LOCATE_ELEMENT" => Self::LOCATE_ELEMENT,
+            "NAVIGATE_TO_LINK" => Self::NAVIGATE_TO_LINK,
+            "OPEN_URL" => Self::OPEN_URL,
+            "PRESS_KEY" => Self::PRESS_KEY,
+            "SERVER_CERTIFICATE" => Self::SERVER_CERTIFICATE,
+            "SELECT_OPTION" => Self::SELECT_OPTION,
+            "STEP_TIMEOUT" => Self::STEP_TIMEOUT,
+            "SUB_TEST_NOT_PASSED" => Self::SUB_TEST_NOT_PASSED,
+            "TEST_TIMEOUT" => Self::TEST_TIMEOUT,
+            "TOO_MANY_HTTP_REQUESTS" => Self::TOO_MANY_HTTP_REQUESTS,
+            "UNAVAILABLE_BROWSER" => Self::UNAVAILABLE_BROWSER,
+            "UNKNOWN" => Self::UNKNOWN,
+            "UNSUPPORTED_AUTH_SCHEMA" => Self::UNSUPPORTED_AUTH_SCHEMA,
+            "UPLOAD_FILES_ELEMENT_TYPE" => Self::UPLOAD_FILES_ELEMENT_TYPE,
+            "UPLOAD_FILES_DIALOG" => Self::UPLOAD_FILES_DIALOG,
+            "UPLOAD_FILES_DYNAMIC_ELEMENT" => Self::UPLOAD_FILES_DYNAMIC_ELEMENT,
+            "UPLOAD_FILES_NAME" => Self::UPLOAD_FILES_NAME,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_browser_test_type.rs b/src/datadogV1/model/model_synthetics_browser_test_type.rs
index 7e2959153..211fc63bc 100644
--- a/src/datadogV1/model/model_synthetics_browser_test_type.rs
+++ b/src/datadogV1/model/model_synthetics_browser_test_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsBrowserTestType {
-    #[serde(rename = "browser")]
     BROWSER,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SyntheticsBrowserTestType {
         }
     }
 }
+
+impl Serialize for SyntheticsBrowserTestType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsBrowserTestType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "browser" => Self::BROWSER,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_browser_variable_type.rs b/src/datadogV1/model/model_synthetics_browser_variable_type.rs
index 4f1b9dea8..acd0abfae 100644
--- a/src/datadogV1/model/model_synthetics_browser_variable_type.rs
+++ b/src/datadogV1/model/model_synthetics_browser_variable_type.rs
@@ -2,20 +2,15 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsBrowserVariableType {
-    #[serde(rename = "element")]
     ELEMENT,
-    #[serde(rename = "email")]
     EMAIL,
-    #[serde(rename = "global")]
     GLOBAL,
-    #[serde(rename = "javascript")]
     JAVASCRIPT,
-    #[serde(rename = "text")]
     TEXT,
 }
 
@@ -30,3 +25,36 @@ impl ToString for SyntheticsBrowserVariableType {
         }
     }
 }
+
+impl Serialize for SyntheticsBrowserVariableType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsBrowserVariableType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "element" => Self::ELEMENT,
+            "email" => Self::EMAIL,
+            "global" => Self::GLOBAL,
+            "javascript" => Self::JAVASCRIPT,
+            "text" => Self::TEXT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_check_type.rs b/src/datadogV1/model/model_synthetics_check_type.rs
index dde52f535..1e10f8dcc 100644
--- a/src/datadogV1/model/model_synthetics_check_type.rs
+++ b/src/datadogV1/model/model_synthetics_check_type.rs
@@ -2,38 +2,24 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsCheckType {
-    #[serde(rename = "equals")]
     EQUALS,
-    #[serde(rename = "notEquals")]
     NOT_EQUALS,
-    #[serde(rename = "contains")]
     CONTAINS,
-    #[serde(rename = "notContains")]
     NOT_CONTAINS,
-    #[serde(rename = "startsWith")]
     STARTS_WITH,
-    #[serde(rename = "notStartsWith")]
     NOT_STARTS_WITH,
-    #[serde(rename = "greater")]
     GREATER,
-    #[serde(rename = "lower")]
     LOWER,
-    #[serde(rename = "greaterEquals")]
     GREATER_EQUALS,
-    #[serde(rename = "lowerEquals")]
     LOWER_EQUALS,
-    #[serde(rename = "matchRegex")]
     MATCH_REGEX,
-    #[serde(rename = "between")]
     BETWEEN,
-    #[serde(rename = "isEmpty")]
     IS_EMPTY,
-    #[serde(rename = "notIsEmpty")]
     NOT_IS_EMPTY,
 }
 
@@ -57,3 +43,45 @@ impl ToString for SyntheticsCheckType {
         }
     }
 }
+
+impl Serialize for SyntheticsCheckType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsCheckType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "equals" => Self::EQUALS,
+            "notEquals" => Self::NOT_EQUALS,
+            "contains" => Self::CONTAINS,
+            "notContains" => Self::NOT_CONTAINS,
+            "startsWith" => Self::STARTS_WITH,
+            "notStartsWith" => Self::NOT_STARTS_WITH,
+            "greater" => Self::GREATER,
+            "lower" => Self::LOWER,
+            "greaterEquals" => Self::GREATER_EQUALS,
+            "lowerEquals" => Self::LOWER_EQUALS,
+            "matchRegex" => Self::MATCH_REGEX,
+            "between" => Self::BETWEEN,
+            "isEmpty" => Self::IS_EMPTY,
+            "notIsEmpty" => Self::NOT_IS_EMPTY,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_config_variable_type.rs b/src/datadogV1/model/model_synthetics_config_variable_type.rs
index 608a3c894..a0c90744e 100644
--- a/src/datadogV1/model/model_synthetics_config_variable_type.rs
+++ b/src/datadogV1/model/model_synthetics_config_variable_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsConfigVariableType {
-    #[serde(rename = "global")]
     GLOBAL,
-    #[serde(rename = "text")]
     TEXT,
 }
 
@@ -21,3 +19,33 @@ impl ToString for SyntheticsConfigVariableType {
         }
     }
 }
+
+impl Serialize for SyntheticsConfigVariableType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsConfigVariableType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "global" => Self::GLOBAL,
+            "text" => Self::TEXT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_device_id.rs b/src/datadogV1/model/model_synthetics_device_id.rs
index 501b022c3..e30e3e801 100644
--- a/src/datadogV1/model/model_synthetics_device_id.rs
+++ b/src/datadogV1/model/model_synthetics_device_id.rs
@@ -2,34 +2,22 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsDeviceID {
-    #[serde(rename = "laptop_large")]
     LAPTOP_LARGE,
-    #[serde(rename = "tablet")]
     TABLET,
-    #[serde(rename = "mobile_small")]
     MOBILE_SMALL,
-    #[serde(rename = "chrome.laptop_large")]
     CHROME_LAPTOP_LARGE,
-    #[serde(rename = "chrome.tablet")]
     CHROME_TABLET,
-    #[serde(rename = "chrome.mobile_small")]
     CHROME_MOBILE_SMALL,
-    #[serde(rename = "firefox.laptop_large")]
     FIREFOX_LAPTOP_LARGE,
-    #[serde(rename = "firefox.tablet")]
     FIREFOX_TABLET,
-    #[serde(rename = "firefox.mobile_small")]
     FIREFOX_MOBILE_SMALL,
-    #[serde(rename = "edge.laptop_large")]
     EDGE_LAPTOP_LARGE,
-    #[serde(rename = "edge.tablet")]
     EDGE_TABLET,
-    #[serde(rename = "edge.mobile_small")]
     EDGE_MOBILE_SMALL,
 }
 
@@ -51,3 +39,43 @@ impl ToString for SyntheticsDeviceID {
         }
     }
 }
+
+impl Serialize for SyntheticsDeviceID {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsDeviceID {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "laptop_large" => Self::LAPTOP_LARGE,
+            "tablet" => Self::TABLET,
+            "mobile_small" => Self::MOBILE_SMALL,
+            "chrome.laptop_large" => Self::CHROME_LAPTOP_LARGE,
+            "chrome.tablet" => Self::CHROME_TABLET,
+            "chrome.mobile_small" => Self::CHROME_MOBILE_SMALL,
+            "firefox.laptop_large" => Self::FIREFOX_LAPTOP_LARGE,
+            "firefox.tablet" => Self::FIREFOX_TABLET,
+            "firefox.mobile_small" => Self::FIREFOX_MOBILE_SMALL,
+            "edge.laptop_large" => Self::EDGE_LAPTOP_LARGE,
+            "edge.tablet" => Self::EDGE_TABLET,
+            "edge.mobile_small" => Self::EDGE_MOBILE_SMALL,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_global_variable_parse_test_options_type.rs b/src/datadogV1/model/model_synthetics_global_variable_parse_test_options_type.rs
index 5d436fd25..e5341d831 100644
--- a/src/datadogV1/model/model_synthetics_global_variable_parse_test_options_type.rs
+++ b/src/datadogV1/model/model_synthetics_global_variable_parse_test_options_type.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsGlobalVariableParseTestOptionsType {
-    #[serde(rename = "http_body")]
     HTTP_BODY,
-    #[serde(rename = "http_header")]
     HTTP_HEADER,
-    #[serde(rename = "local_variable")]
     LOCAL_VARIABLE,
 }
 
@@ -24,3 +21,34 @@ impl ToString for SyntheticsGlobalVariableParseTestOptionsType {
         }
     }
 }
+
+impl Serialize for SyntheticsGlobalVariableParseTestOptionsType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsGlobalVariableParseTestOptionsType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "http_body" => Self::HTTP_BODY,
+            "http_header" => Self::HTTP_HEADER,
+            "local_variable" => Self::LOCAL_VARIABLE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_global_variable_parser_type.rs b/src/datadogV1/model/model_synthetics_global_variable_parser_type.rs
index 6c8d17041..570a01a5c 100644
--- a/src/datadogV1/model/model_synthetics_global_variable_parser_type.rs
+++ b/src/datadogV1/model/model_synthetics_global_variable_parser_type.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsGlobalVariableParserType {
-    #[serde(rename = "raw")]
     RAW,
-    #[serde(rename = "json_path")]
     JSON_PATH,
-    #[serde(rename = "regex")]
     REGEX,
-    #[serde(rename = "x_path")]
     X_PATH,
 }
 
@@ -27,3 +23,35 @@ impl ToString for SyntheticsGlobalVariableParserType {
         }
     }
 }
+
+impl Serialize for SyntheticsGlobalVariableParserType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsGlobalVariableParserType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "raw" => Self::RAW,
+            "json_path" => Self::JSON_PATH,
+            "regex" => Self::REGEX,
+            "x_path" => Self::X_PATH,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_patch_test_operation_name.rs b/src/datadogV1/model/model_synthetics_patch_test_operation_name.rs
index 1848db76a..753b2c934 100644
--- a/src/datadogV1/model/model_synthetics_patch_test_operation_name.rs
+++ b/src/datadogV1/model/model_synthetics_patch_test_operation_name.rs
@@ -2,22 +2,16 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsPatchTestOperationName {
-    #[serde(rename = "add")]
     ADD,
-    #[serde(rename = "remove")]
     REMOVE,
-    #[serde(rename = "replace")]
     REPLACE,
-    #[serde(rename = "move")]
     MOVE,
-    #[serde(rename = "copy")]
     COPY,
-    #[serde(rename = "test")]
     TEST,
 }
 
@@ -33,3 +27,37 @@ impl ToString for SyntheticsPatchTestOperationName {
         }
     }
 }
+
+impl Serialize for SyntheticsPatchTestOperationName {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsPatchTestOperationName {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "add" => Self::ADD,
+            "remove" => Self::REMOVE,
+            "replace" => Self::REPLACE,
+            "move" => Self::MOVE,
+            "copy" => Self::COPY,
+            "test" => Self::TEST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_playing_tab.rs b/src/datadogV1/model/model_synthetics_playing_tab.rs
index 8f277bd04..0fcccf50a 100644
--- a/src/datadogV1/model/model_synthetics_playing_tab.rs
+++ b/src/datadogV1/model/model_synthetics_playing_tab.rs
@@ -2,29 +2,51 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde_repr::{Deserialize_repr, Serialize_repr};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(
-    Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize_repr, Deserialize_repr,
-)]
-#[repr(i64)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsPlayingTab {
-    MAIN_TAB = -1,
-    NEW_TAB = 0,
-    TAB_1 = 1,
-    TAB_2 = 2,
-    TAB_3 = 3,
+    MAIN_TAB,
+    NEW_TAB,
+    TAB_1,
+    TAB_2,
+    TAB_3,
 }
 
-impl ToString for SyntheticsPlayingTab {
-    fn to_string(&self) -> String {
+impl Serialize for SyntheticsPlayingTab {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
         match self {
-            Self::MAIN_TAB => String::from("-1"),
-            Self::NEW_TAB => String::from("0"),
-            Self::TAB_1 => String::from("1"),
-            Self::TAB_2 => String::from("2"),
-            Self::TAB_3 => String::from("3"),
+            Self::MAIN_TAB => serializer.serialize_i64(-1),
+            Self::NEW_TAB => serializer.serialize_i64(0),
+            Self::TAB_1 => serializer.serialize_i64(1),
+            Self::TAB_2 => serializer.serialize_i64(2),
+            Self::TAB_3 => serializer.serialize_i64(3),
         }
     }
 }
+
+impl<'de> Deserialize<'de> for SyntheticsPlayingTab {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: i64 = i64::deserialize(deserializer)?;
+        Ok(match s {
+            -1 => Self::MAIN_TAB,
+            0 => Self::NEW_TAB,
+            1 => Self::TAB_1,
+            2 => Self::TAB_2,
+            3 => Self::TAB_3,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_status.rs b/src/datadogV1/model/model_synthetics_status.rs
index 48cd4fbd2..1d4cf3fba 100644
--- a/src/datadogV1/model/model_synthetics_status.rs
+++ b/src/datadogV1/model/model_synthetics_status.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsStatus {
-    #[serde(rename = "passed")]
     PASSED,
-    #[serde(rename = "skipped")]
     skipped,
-    #[serde(rename = "failed")]
     failed,
 }
 
@@ -24,3 +21,34 @@ impl ToString for SyntheticsStatus {
         }
     }
 }
+
+impl Serialize for SyntheticsStatus {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsStatus {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "passed" => Self::PASSED,
+            "skipped" => Self::skipped,
+            "failed" => Self::failed,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_step_type.rs b/src/datadogV1/model/model_synthetics_step_type.rs
index 8a48199d3..215065bbd 100644
--- a/src/datadogV1/model/model_synthetics_step_type.rs
+++ b/src/datadogV1/model/model_synthetics_step_type.rs
@@ -2,60 +2,35 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsStepType {
-    #[serde(rename = "assertCurrentUrl")]
     ASSERT_CURRENT_URL,
-    #[serde(rename = "assertElementAttribute")]
     ASSERT_ELEMENT_ATTRIBUTE,
-    #[serde(rename = "assertElementContent")]
     ASSERT_ELEMENT_CONTENT,
-    #[serde(rename = "assertElementPresent")]
     ASSERT_ELEMENT_PRESENT,
-    #[serde(rename = "assertEmail")]
     ASSERT_EMAIL,
-    #[serde(rename = "assertFileDownload")]
     ASSERT_FILE_DOWNLOAD,
-    #[serde(rename = "assertFromJavascript")]
     ASSERT_FROM_JAVASCRIPT,
-    #[serde(rename = "assertPageContains")]
     ASSERT_PAGE_CONTAINS,
-    #[serde(rename = "assertPageLacks")]
     ASSERT_PAGE_LACKS,
-    #[serde(rename = "click")]
     CLICK,
-    #[serde(rename = "extractFromJavascript")]
     EXTRACT_FROM_JAVASCRIPT,
-    #[serde(rename = "extractVariable")]
     EXTRACT_VARIABLE,
-    #[serde(rename = "goToEmailLink")]
     GO_TO_EMAIL_LINK,
-    #[serde(rename = "goToUrl")]
     GO_TO_URL,
-    #[serde(rename = "goToUrlAndMeasureTti")]
     GO_TO_URL_AND_MEASURE_TTI,
-    #[serde(rename = "hover")]
     HOVER,
-    #[serde(rename = "playSubTest")]
     PLAY_SUB_TEST,
-    #[serde(rename = "pressKey")]
     PRESS_KEY,
-    #[serde(rename = "refresh")]
     REFRESH,
-    #[serde(rename = "runApiTest")]
     RUN_API_TEST,
-    #[serde(rename = "scroll")]
     SCROLL,
-    #[serde(rename = "selectOption")]
     SELECT_OPTION,
-    #[serde(rename = "typeText")]
     TYPE_TEXT,
-    #[serde(rename = "uploadFiles")]
     UPLOAD_FILES,
-    #[serde(rename = "wait")]
     WAIT,
 }
 
@@ -90,3 +65,56 @@ impl ToString for SyntheticsStepType {
         }
     }
 }
+
+impl Serialize for SyntheticsStepType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsStepType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "assertCurrentUrl" => Self::ASSERT_CURRENT_URL,
+            "assertElementAttribute" => Self::ASSERT_ELEMENT_ATTRIBUTE,
+            "assertElementContent" => Self::ASSERT_ELEMENT_CONTENT,
+            "assertElementPresent" => Self::ASSERT_ELEMENT_PRESENT,
+            "assertEmail" => Self::ASSERT_EMAIL,
+            "assertFileDownload" => Self::ASSERT_FILE_DOWNLOAD,
+            "assertFromJavascript" => Self::ASSERT_FROM_JAVASCRIPT,
+            "assertPageContains" => Self::ASSERT_PAGE_CONTAINS,
+            "assertPageLacks" => Self::ASSERT_PAGE_LACKS,
+            "click" => Self::CLICK,
+            "extractFromJavascript" => Self::EXTRACT_FROM_JAVASCRIPT,
+            "extractVariable" => Self::EXTRACT_VARIABLE,
+            "goToEmailLink" => Self::GO_TO_EMAIL_LINK,
+            "goToUrl" => Self::GO_TO_URL,
+            "goToUrlAndMeasureTti" => Self::GO_TO_URL_AND_MEASURE_TTI,
+            "hover" => Self::HOVER,
+            "playSubTest" => Self::PLAY_SUB_TEST,
+            "pressKey" => Self::PRESS_KEY,
+            "refresh" => Self::REFRESH,
+            "runApiTest" => Self::RUN_API_TEST,
+            "scroll" => Self::SCROLL,
+            "selectOption" => Self::SELECT_OPTION,
+            "typeText" => Self::TYPE_TEXT,
+            "uploadFiles" => Self::UPLOAD_FILES,
+            "wait" => Self::WAIT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_test_call_type.rs b/src/datadogV1/model/model_synthetics_test_call_type.rs
index 9e9d86fef..360f01ff5 100644
--- a/src/datadogV1/model/model_synthetics_test_call_type.rs
+++ b/src/datadogV1/model/model_synthetics_test_call_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsTestCallType {
-    #[serde(rename = "healthcheck")]
     HEALTHCHECK,
-    #[serde(rename = "unary")]
     UNARY,
 }
 
@@ -21,3 +19,33 @@ impl ToString for SyntheticsTestCallType {
         }
     }
 }
+
+impl Serialize for SyntheticsTestCallType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsTestCallType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "healthcheck" => Self::HEALTHCHECK,
+            "unary" => Self::UNARY,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_test_details_sub_type.rs b/src/datadogV1/model/model_synthetics_test_details_sub_type.rs
index 4176395c6..51eb8e679 100644
--- a/src/datadogV1/model/model_synthetics_test_details_sub_type.rs
+++ b/src/datadogV1/model/model_synthetics_test_details_sub_type.rs
@@ -2,28 +2,19 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsTestDetailsSubType {
-    #[serde(rename = "http")]
     HTTP,
-    #[serde(rename = "ssl")]
     SSL,
-    #[serde(rename = "tcp")]
     TCP,
-    #[serde(rename = "dns")]
     DNS,
-    #[serde(rename = "multi")]
     MULTI,
-    #[serde(rename = "icmp")]
     ICMP,
-    #[serde(rename = "udp")]
     UDP,
-    #[serde(rename = "websocket")]
     WEBSOCKET,
-    #[serde(rename = "grpc")]
     GRPC,
 }
 
@@ -42,3 +33,40 @@ impl ToString for SyntheticsTestDetailsSubType {
         }
     }
 }
+
+impl Serialize for SyntheticsTestDetailsSubType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsTestDetailsSubType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "http" => Self::HTTP,
+            "ssl" => Self::SSL,
+            "tcp" => Self::TCP,
+            "dns" => Self::DNS,
+            "multi" => Self::MULTI,
+            "icmp" => Self::ICMP,
+            "udp" => Self::UDP,
+            "websocket" => Self::WEBSOCKET,
+            "grpc" => Self::GRPC,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_test_details_type.rs b/src/datadogV1/model/model_synthetics_test_details_type.rs
index d98f269ce..55b9b2c81 100644
--- a/src/datadogV1/model/model_synthetics_test_details_type.rs
+++ b/src/datadogV1/model/model_synthetics_test_details_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsTestDetailsType {
-    #[serde(rename = "api")]
     API,
-    #[serde(rename = "browser")]
     BROWSER,
 }
 
@@ -21,3 +19,33 @@ impl ToString for SyntheticsTestDetailsType {
         }
     }
 }
+
+impl Serialize for SyntheticsTestDetailsType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsTestDetailsType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "api" => Self::API,
+            "browser" => Self::BROWSER,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_test_execution_rule.rs b/src/datadogV1/model/model_synthetics_test_execution_rule.rs
index 0e8e2213c..53d5b709b 100644
--- a/src/datadogV1/model/model_synthetics_test_execution_rule.rs
+++ b/src/datadogV1/model/model_synthetics_test_execution_rule.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsTestExecutionRule {
-    #[serde(rename = "blocking")]
     BLOCKING,
-    #[serde(rename = "non_blocking")]
     NON_BLOCKING,
-    #[serde(rename = "skipped")]
     SKIPPED,
 }
 
@@ -24,3 +21,34 @@ impl ToString for SyntheticsTestExecutionRule {
         }
     }
 }
+
+impl Serialize for SyntheticsTestExecutionRule {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsTestExecutionRule {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "blocking" => Self::BLOCKING,
+            "non_blocking" => Self::NON_BLOCKING,
+            "skipped" => Self::SKIPPED,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_test_monitor_status.rs b/src/datadogV1/model/model_synthetics_test_monitor_status.rs
index 14af4029e..1eebc568d 100644
--- a/src/datadogV1/model/model_synthetics_test_monitor_status.rs
+++ b/src/datadogV1/model/model_synthetics_test_monitor_status.rs
@@ -2,25 +2,45 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde_repr::{Deserialize_repr, Serialize_repr};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(
-    Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize_repr, Deserialize_repr,
-)]
-#[repr(i64)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsTestMonitorStatus {
-    UNTRIGGERED = 0,
-    TRIGGERED = 1,
-    NO_DATA = 2,
+    UNTRIGGERED,
+    TRIGGERED,
+    NO_DATA,
 }
 
-impl ToString for SyntheticsTestMonitorStatus {
-    fn to_string(&self) -> String {
+impl Serialize for SyntheticsTestMonitorStatus {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
         match self {
-            Self::UNTRIGGERED => String::from("0"),
-            Self::TRIGGERED => String::from("1"),
-            Self::NO_DATA => String::from("2"),
+            Self::UNTRIGGERED => serializer.serialize_i64(0),
+            Self::TRIGGERED => serializer.serialize_i64(1),
+            Self::NO_DATA => serializer.serialize_i64(2),
         }
     }
 }
+
+impl<'de> Deserialize<'de> for SyntheticsTestMonitorStatus {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: i64 = i64::deserialize(deserializer)?;
+        Ok(match s {
+            0 => Self::UNTRIGGERED,
+            1 => Self::TRIGGERED,
+            2 => Self::NO_DATA,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_test_options_http_version.rs b/src/datadogV1/model/model_synthetics_test_options_http_version.rs
index 4af7e46f6..70200ba44 100644
--- a/src/datadogV1/model/model_synthetics_test_options_http_version.rs
+++ b/src/datadogV1/model/model_synthetics_test_options_http_version.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsTestOptionsHTTPVersion {
-    #[serde(rename = "http1")]
     HTTP1,
-    #[serde(rename = "http2")]
     HTTP2,
-    #[serde(rename = "any")]
     ANY,
 }
 
@@ -24,3 +21,34 @@ impl ToString for SyntheticsTestOptionsHTTPVersion {
         }
     }
 }
+
+impl Serialize for SyntheticsTestOptionsHTTPVersion {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsTestOptionsHTTPVersion {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "http1" => Self::HTTP1,
+            "http2" => Self::HTTP2,
+            "any" => Self::ANY,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_test_pause_status.rs b/src/datadogV1/model/model_synthetics_test_pause_status.rs
index 3f3f6503e..7c76500c8 100644
--- a/src/datadogV1/model/model_synthetics_test_pause_status.rs
+++ b/src/datadogV1/model/model_synthetics_test_pause_status.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsTestPauseStatus {
-    #[serde(rename = "live")]
     LIVE,
-    #[serde(rename = "paused")]
     PAUSED,
 }
 
@@ -21,3 +19,33 @@ impl ToString for SyntheticsTestPauseStatus {
         }
     }
 }
+
+impl Serialize for SyntheticsTestPauseStatus {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsTestPauseStatus {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "live" => Self::LIVE,
+            "paused" => Self::PAUSED,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_test_process_status.rs b/src/datadogV1/model/model_synthetics_test_process_status.rs
index 5666d4cc7..8a0bf5496 100644
--- a/src/datadogV1/model/model_synthetics_test_process_status.rs
+++ b/src/datadogV1/model/model_synthetics_test_process_status.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsTestProcessStatus {
-    #[serde(rename = "not_scheduled")]
     NOT_SCHEDULED,
-    #[serde(rename = "scheduled")]
     SCHEDULED,
-    #[serde(rename = "finished")]
     FINISHED,
-    #[serde(rename = "finished_with_error")]
     FINISHED_WITH_ERROR,
 }
 
@@ -27,3 +23,35 @@ impl ToString for SyntheticsTestProcessStatus {
         }
     }
 }
+
+impl Serialize for SyntheticsTestProcessStatus {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsTestProcessStatus {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "not_scheduled" => Self::NOT_SCHEDULED,
+            "scheduled" => Self::SCHEDULED,
+            "finished" => Self::FINISHED,
+            "finished_with_error" => Self::FINISHED_WITH_ERROR,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_test_request_body_type.rs b/src/datadogV1/model/model_synthetics_test_request_body_type.rs
index 42b1e00ad..a6bc04aa5 100644
--- a/src/datadogV1/model/model_synthetics_test_request_body_type.rs
+++ b/src/datadogV1/model/model_synthetics_test_request_body_type.rs
@@ -2,22 +2,16 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsTestRequestBodyType {
-    #[serde(rename = "text/plain")]
     TEXT_PLAIN,
-    #[serde(rename = "application/json")]
     APPLICATION_JSON,
-    #[serde(rename = "text/xml")]
     TEXT_XML,
-    #[serde(rename = "text/html")]
     TEXT_HTML,
-    #[serde(rename = "application/x-www-form-urlencoded")]
     APPLICATION_X_WWW_FORM_URLENCODED,
-    #[serde(rename = "graphql")]
     GRAPHQL,
 }
 
@@ -35,3 +29,37 @@ impl ToString for SyntheticsTestRequestBodyType {
         }
     }
 }
+
+impl Serialize for SyntheticsTestRequestBodyType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsTestRequestBodyType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "text/plain" => Self::TEXT_PLAIN,
+            "application/json" => Self::APPLICATION_JSON,
+            "text/xml" => Self::TEXT_XML,
+            "text/html" => Self::TEXT_HTML,
+            "application/x-www-form-urlencoded" => Self::APPLICATION_X_WWW_FORM_URLENCODED,
+            "graphql" => Self::GRAPHQL,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_synthetics_warning_type.rs b/src/datadogV1/model/model_synthetics_warning_type.rs
index 26a6d2d71..3b9f861ac 100644
--- a/src/datadogV1/model/model_synthetics_warning_type.rs
+++ b/src/datadogV1/model/model_synthetics_warning_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SyntheticsWarningType {
-    #[serde(rename = "user_locator")]
     USER_LOCATOR,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SyntheticsWarningType {
         }
     }
 }
+
+impl Serialize for SyntheticsWarningType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SyntheticsWarningType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "user_locator" => Self::USER_LOCATOR,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_table_widget_cell_display_mode.rs b/src/datadogV1/model/model_table_widget_cell_display_mode.rs
index d59a68a1c..af50c2c25 100644
--- a/src/datadogV1/model/model_table_widget_cell_display_mode.rs
+++ b/src/datadogV1/model/model_table_widget_cell_display_mode.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum TableWidgetCellDisplayMode {
-    #[serde(rename = "number")]
     NUMBER,
-    #[serde(rename = "bar")]
     BAR,
 }
 
@@ -21,3 +19,33 @@ impl ToString for TableWidgetCellDisplayMode {
         }
     }
 }
+
+impl Serialize for TableWidgetCellDisplayMode {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TableWidgetCellDisplayMode {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "number" => Self::NUMBER,
+            "bar" => Self::BAR,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_table_widget_definition_type.rs b/src/datadogV1/model/model_table_widget_definition_type.rs
index 85fc0391b..e66b2eb18 100644
--- a/src/datadogV1/model/model_table_widget_definition_type.rs
+++ b/src/datadogV1/model/model_table_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum TableWidgetDefinitionType {
-    #[serde(rename = "query_table")]
     QUERY_TABLE,
 }
 
@@ -18,3 +17,32 @@ impl ToString for TableWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for TableWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TableWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "query_table" => Self::QUERY_TABLE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_table_widget_has_search_bar.rs b/src/datadogV1/model/model_table_widget_has_search_bar.rs
index f08a968f2..75865651c 100644
--- a/src/datadogV1/model/model_table_widget_has_search_bar.rs
+++ b/src/datadogV1/model/model_table_widget_has_search_bar.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum TableWidgetHasSearchBar {
-    #[serde(rename = "always")]
     ALWAYS,
-    #[serde(rename = "never")]
     NEVER,
-    #[serde(rename = "auto")]
     AUTO,
 }
 
@@ -24,3 +21,34 @@ impl ToString for TableWidgetHasSearchBar {
         }
     }
 }
+
+impl Serialize for TableWidgetHasSearchBar {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TableWidgetHasSearchBar {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "always" => Self::ALWAYS,
+            "never" => Self::NEVER,
+            "auto" => Self::AUTO,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_target_format_type.rs b/src/datadogV1/model/model_target_format_type.rs
index 5ed2c1607..b3aeef064 100644
--- a/src/datadogV1/model/model_target_format_type.rs
+++ b/src/datadogV1/model/model_target_format_type.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum TargetFormatType {
-    #[serde(rename = "auto")]
     AUTO,
-    #[serde(rename = "string")]
     STRING,
-    #[serde(rename = "integer")]
     INTEGER,
-    #[serde(rename = "double")]
     DOUBLE,
 }
 
@@ -27,3 +23,35 @@ impl ToString for TargetFormatType {
         }
     }
 }
+
+impl Serialize for TargetFormatType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TargetFormatType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "auto" => Self::AUTO,
+            "string" => Self::STRING,
+            "integer" => Self::INTEGER,
+            "double" => Self::DOUBLE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_timeseries_background_type.rs b/src/datadogV1/model/model_timeseries_background_type.rs
index 927a2dae0..0f25e7c42 100644
--- a/src/datadogV1/model/model_timeseries_background_type.rs
+++ b/src/datadogV1/model/model_timeseries_background_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum TimeseriesBackgroundType {
-    #[serde(rename = "bars")]
     BARS,
-    #[serde(rename = "area")]
     AREA,
 }
 
@@ -21,3 +19,33 @@ impl ToString for TimeseriesBackgroundType {
         }
     }
 }
+
+impl Serialize for TimeseriesBackgroundType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TimeseriesBackgroundType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "bars" => Self::BARS,
+            "area" => Self::AREA,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_timeseries_widget_definition_type.rs b/src/datadogV1/model/model_timeseries_widget_definition_type.rs
index 6c8366553..b22746fda 100644
--- a/src/datadogV1/model/model_timeseries_widget_definition_type.rs
+++ b/src/datadogV1/model/model_timeseries_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum TimeseriesWidgetDefinitionType {
-    #[serde(rename = "timeseries")]
     TIMESERIES,
 }
 
@@ -18,3 +17,32 @@ impl ToString for TimeseriesWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for TimeseriesWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TimeseriesWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "timeseries" => Self::TIMESERIES,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_timeseries_widget_legend_column.rs b/src/datadogV1/model/model_timeseries_widget_legend_column.rs
index eabb206a1..452120d49 100644
--- a/src/datadogV1/model/model_timeseries_widget_legend_column.rs
+++ b/src/datadogV1/model/model_timeseries_widget_legend_column.rs
@@ -2,20 +2,15 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum TimeseriesWidgetLegendColumn {
-    #[serde(rename = "value")]
     VALUE,
-    #[serde(rename = "avg")]
     AVG,
-    #[serde(rename = "sum")]
     SUM,
-    #[serde(rename = "min")]
     MIN,
-    #[serde(rename = "max")]
     MAX,
 }
 
@@ -30,3 +25,36 @@ impl ToString for TimeseriesWidgetLegendColumn {
         }
     }
 }
+
+impl Serialize for TimeseriesWidgetLegendColumn {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TimeseriesWidgetLegendColumn {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "value" => Self::VALUE,
+            "avg" => Self::AVG,
+            "sum" => Self::SUM,
+            "min" => Self::MIN,
+            "max" => Self::MAX,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_timeseries_widget_legend_layout.rs b/src/datadogV1/model/model_timeseries_widget_legend_layout.rs
index a810604db..5362cbcf6 100644
--- a/src/datadogV1/model/model_timeseries_widget_legend_layout.rs
+++ b/src/datadogV1/model/model_timeseries_widget_legend_layout.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum TimeseriesWidgetLegendLayout {
-    #[serde(rename = "auto")]
     AUTO,
-    #[serde(rename = "horizontal")]
     HORIZONTAL,
-    #[serde(rename = "vertical")]
     VERTICAL,
 }
 
@@ -24,3 +21,34 @@ impl ToString for TimeseriesWidgetLegendLayout {
         }
     }
 }
+
+impl Serialize for TimeseriesWidgetLegendLayout {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TimeseriesWidgetLegendLayout {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "auto" => Self::AUTO,
+            "horizontal" => Self::HORIZONTAL,
+            "vertical" => Self::VERTICAL,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_toplist_widget_definition_type.rs b/src/datadogV1/model/model_toplist_widget_definition_type.rs
index 743d425e2..bb71a63a0 100644
--- a/src/datadogV1/model/model_toplist_widget_definition_type.rs
+++ b/src/datadogV1/model/model_toplist_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ToplistWidgetDefinitionType {
-    #[serde(rename = "toplist")]
     TOPLIST,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ToplistWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for ToplistWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ToplistWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "toplist" => Self::TOPLIST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_toplist_widget_flat_type.rs b/src/datadogV1/model/model_toplist_widget_flat_type.rs
index 077d91270..267e7fad7 100644
--- a/src/datadogV1/model/model_toplist_widget_flat_type.rs
+++ b/src/datadogV1/model/model_toplist_widget_flat_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ToplistWidgetFlatType {
-    #[serde(rename = "flat")]
     FLAT,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ToplistWidgetFlatType {
         }
     }
 }
+
+impl Serialize for ToplistWidgetFlatType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ToplistWidgetFlatType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "flat" => Self::FLAT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_toplist_widget_legend.rs b/src/datadogV1/model/model_toplist_widget_legend.rs
index fdb35acae..ed2bff07c 100644
--- a/src/datadogV1/model/model_toplist_widget_legend.rs
+++ b/src/datadogV1/model/model_toplist_widget_legend.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ToplistWidgetLegend {
-    #[serde(rename = "automatic")]
     AUTOMATIC,
-    #[serde(rename = "inline")]
     INLINE,
-    #[serde(rename = "none")]
     NONE,
 }
 
@@ -24,3 +21,34 @@ impl ToString for ToplistWidgetLegend {
         }
     }
 }
+
+impl Serialize for ToplistWidgetLegend {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ToplistWidgetLegend {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "automatic" => Self::AUTOMATIC,
+            "inline" => Self::INLINE,
+            "none" => Self::NONE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_toplist_widget_scaling.rs b/src/datadogV1/model/model_toplist_widget_scaling.rs
index 2ae0ecfa3..9ff62c3b2 100644
--- a/src/datadogV1/model/model_toplist_widget_scaling.rs
+++ b/src/datadogV1/model/model_toplist_widget_scaling.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ToplistWidgetScaling {
-    #[serde(rename = "absolute")]
     ABSOLUTE,
-    #[serde(rename = "relative")]
     RELATIVE,
 }
 
@@ -21,3 +19,33 @@ impl ToString for ToplistWidgetScaling {
         }
     }
 }
+
+impl Serialize for ToplistWidgetScaling {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ToplistWidgetScaling {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "absolute" => Self::ABSOLUTE,
+            "relative" => Self::RELATIVE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_toplist_widget_stacked_type.rs b/src/datadogV1/model/model_toplist_widget_stacked_type.rs
index e55edd397..f98804acd 100644
--- a/src/datadogV1/model/model_toplist_widget_stacked_type.rs
+++ b/src/datadogV1/model/model_toplist_widget_stacked_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ToplistWidgetStackedType {
-    #[serde(rename = "stacked")]
     STACKED,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ToplistWidgetStackedType {
         }
     }
 }
+
+impl Serialize for ToplistWidgetStackedType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ToplistWidgetStackedType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "stacked" => Self::STACKED,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_topology_map_widget_definition_type.rs b/src/datadogV1/model/model_topology_map_widget_definition_type.rs
index f67782673..e41f17afa 100644
--- a/src/datadogV1/model/model_topology_map_widget_definition_type.rs
+++ b/src/datadogV1/model/model_topology_map_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum TopologyMapWidgetDefinitionType {
-    #[serde(rename = "topology_map")]
     TOPOLOGY_MAP,
 }
 
@@ -18,3 +17,32 @@ impl ToString for TopologyMapWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for TopologyMapWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TopologyMapWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "topology_map" => Self::TOPOLOGY_MAP,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_topology_query_data_source.rs b/src/datadogV1/model/model_topology_query_data_source.rs
index 86f03c488..d26f60d90 100644
--- a/src/datadogV1/model/model_topology_query_data_source.rs
+++ b/src/datadogV1/model/model_topology_query_data_source.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum TopologyQueryDataSource {
-    #[serde(rename = "data_streams")]
     DATA_STREAMS,
-    #[serde(rename = "service_map")]
     SERVICE_MAP,
 }
 
@@ -21,3 +19,33 @@ impl ToString for TopologyQueryDataSource {
         }
     }
 }
+
+impl Serialize for TopologyQueryDataSource {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TopologyQueryDataSource {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "data_streams" => Self::DATA_STREAMS,
+            "service_map" => Self::SERVICE_MAP,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_topology_request_type.rs b/src/datadogV1/model/model_topology_request_type.rs
index 3930c3a6c..7643e6bcf 100644
--- a/src/datadogV1/model/model_topology_request_type.rs
+++ b/src/datadogV1/model/model_topology_request_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum TopologyRequestType {
-    #[serde(rename = "topology")]
     TOPOLOGY,
 }
 
@@ -18,3 +17,32 @@ impl ToString for TopologyRequestType {
         }
     }
 }
+
+impl Serialize for TopologyRequestType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TopologyRequestType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "topology" => Self::TOPOLOGY,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_tree_map_color_by.rs b/src/datadogV1/model/model_tree_map_color_by.rs
index 46f0c9d8d..647e89461 100644
--- a/src/datadogV1/model/model_tree_map_color_by.rs
+++ b/src/datadogV1/model/model_tree_map_color_by.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum TreeMapColorBy {
-    #[serde(rename = "user")]
     USER,
 }
 
@@ -18,3 +17,32 @@ impl ToString for TreeMapColorBy {
         }
     }
 }
+
+impl Serialize for TreeMapColorBy {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TreeMapColorBy {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "user" => Self::USER,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_tree_map_group_by.rs b/src/datadogV1/model/model_tree_map_group_by.rs
index ea5bc807b..80f32b2f2 100644
--- a/src/datadogV1/model/model_tree_map_group_by.rs
+++ b/src/datadogV1/model/model_tree_map_group_by.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum TreeMapGroupBy {
-    #[serde(rename = "user")]
     USER,
-    #[serde(rename = "family")]
     FAMILY,
-    #[serde(rename = "process")]
     PROCESS,
 }
 
@@ -24,3 +21,34 @@ impl ToString for TreeMapGroupBy {
         }
     }
 }
+
+impl Serialize for TreeMapGroupBy {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TreeMapGroupBy {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "user" => Self::USER,
+            "family" => Self::FAMILY,
+            "process" => Self::PROCESS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_tree_map_size_by.rs b/src/datadogV1/model/model_tree_map_size_by.rs
index 18953a6c1..4a685b709 100644
--- a/src/datadogV1/model/model_tree_map_size_by.rs
+++ b/src/datadogV1/model/model_tree_map_size_by.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum TreeMapSizeBy {
-    #[serde(rename = "pct_cpu")]
     PCT_CPU,
-    #[serde(rename = "pct_mem")]
     PCT_MEM,
 }
 
@@ -21,3 +19,33 @@ impl ToString for TreeMapSizeBy {
         }
     }
 }
+
+impl Serialize for TreeMapSizeBy {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TreeMapSizeBy {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "pct_cpu" => Self::PCT_CPU,
+            "pct_mem" => Self::PCT_MEM,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_tree_map_widget_definition_type.rs b/src/datadogV1/model/model_tree_map_widget_definition_type.rs
index f779ce0fd..798ed0eb7 100644
--- a/src/datadogV1/model/model_tree_map_widget_definition_type.rs
+++ b/src/datadogV1/model/model_tree_map_widget_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum TreeMapWidgetDefinitionType {
-    #[serde(rename = "treemap")]
     TREEMAP,
 }
 
@@ -18,3 +17,32 @@ impl ToString for TreeMapWidgetDefinitionType {
         }
     }
 }
+
+impl Serialize for TreeMapWidgetDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TreeMapWidgetDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "treemap" => Self::TREEMAP,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_usage_attribution_sort.rs b/src/datadogV1/model/model_usage_attribution_sort.rs
index 943ec8abf..ebb1eec55 100644
--- a/src/datadogV1/model/model_usage_attribution_sort.rs
+++ b/src/datadogV1/model/model_usage_attribution_sort.rs
@@ -2,82 +2,46 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum UsageAttributionSort {
-    #[serde(rename = "api_percentage")]
     API_PERCENTAGE,
-    #[serde(rename = "snmp_usage")]
     SNMP_USAGE,
-    #[serde(rename = "apm_host_usage")]
     APM_HOST_USAGE,
-    #[serde(rename = "api_usage")]
     API_USAGE,
-    #[serde(rename = "appsec_usage")]
     APPSEC_USAGE,
-    #[serde(rename = "appsec_percentage")]
     APPSEC_PERCENTAGE,
-    #[serde(rename = "container_usage")]
     CONTAINER_USAGE,
-    #[serde(rename = "custom_timeseries_percentage")]
     CUSTOM_TIMESERIES_PERCENTAGE,
-    #[serde(rename = "container_percentage")]
     CONTAINER_PERCENTAGE,
-    #[serde(rename = "apm_host_percentage")]
     APM_HOST_PERCENTAGE,
-    #[serde(rename = "npm_host_percentage")]
     NPM_HOST_PERCENTAGE,
-    #[serde(rename = "browser_percentage")]
     BROWSER_PERCENTAGE,
-    #[serde(rename = "browser_usage")]
     BROWSER_USAGE,
-    #[serde(rename = "infra_host_percentage")]
     INFRA_HOST_PERCENTAGE,
-    #[serde(rename = "snmp_percentage")]
     SNMP_PERCENTAGE,
-    #[serde(rename = "npm_host_usage")]
     NPM_HOST_USAGE,
-    #[serde(rename = "infra_host_usage")]
     INFRA_HOST_USAGE,
-    #[serde(rename = "custom_timeseries_usage")]
     CUSTOM_TIMESERIES_USAGE,
-    #[serde(rename = "lambda_functions_usage")]
     LAMBDA_FUNCTIONS_USAGE,
-    #[serde(rename = "lambda_functions_percentage")]
     LAMBDA_FUNCTIONS_PERCENTAGE,
-    #[serde(rename = "lambda_invocations_usage")]
     LAMBDA_INVOCATIONS_USAGE,
-    #[serde(rename = "lambda_invocations_percentage")]
     LAMBDA_INVOCATIONS_PERCENTAGE,
-    #[serde(rename = "estimated_indexed_logs_usage")]
     ESTIMATED_INDEXED_LOGS_USAGE,
-    #[serde(rename = "estimated_indexed_logs_percentage")]
     ESTIMATED_INDEXED_LOGS_PERCENTAGE,
-    #[serde(rename = "estimated_ingested_logs_usage")]
     ESTIMATED_INGESTED_LOGS_USAGE,
-    #[serde(rename = "estimated_ingested_logs_percentage")]
     ESTIMATED_INGESTED_LOGS_PERCENTAGE,
-    #[serde(rename = "estimated_indexed_spans_usage")]
     ESTIMATED_INDEXED_SPANS_USAGE,
-    #[serde(rename = "estimated_indexed_spans_percentage")]
     ESTIMATED_INDEXED_SPANS_PERCENTAGE,
-    #[serde(rename = "estimated_ingested_spans_usage")]
     ESTIMATED_INGESTED_SPANS_USAGE,
-    #[serde(rename = "estimated_ingested_spans_percentage")]
     ESTIMATED_INGESTED_SPANS_PERCENTAGE,
-    #[serde(rename = "apm_fargate_usage")]
     APM_FARGATE_USAGE,
-    #[serde(rename = "apm_fargate_percentage")]
     APM_FARGATE_PERCENTAGE,
-    #[serde(rename = "appsec_fargate_usage")]
     APPSEC_FARGATE_USAGE,
-    #[serde(rename = "appsec_fargate_percentage")]
     APPSEC_FARGATE_PERCENTAGE,
-    #[serde(rename = "estimated_rum_usage_attribution_usage")]
     ESTIMATED_RUM_USAGE_ATTRIBUTION_USAGE,
-    #[serde(rename = "estimated_rum_usage_attribution_percentage")]
     ESTIMATED_RUM_USAGE_ATTRIBUTION_PERCENTAGE,
 }
 
@@ -135,3 +99,69 @@ impl ToString for UsageAttributionSort {
         }
     }
 }
+
+impl Serialize for UsageAttributionSort {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for UsageAttributionSort {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "api_percentage" => Self::API_PERCENTAGE,
+            "snmp_usage" => Self::SNMP_USAGE,
+            "apm_host_usage" => Self::APM_HOST_USAGE,
+            "api_usage" => Self::API_USAGE,
+            "appsec_usage" => Self::APPSEC_USAGE,
+            "appsec_percentage" => Self::APPSEC_PERCENTAGE,
+            "container_usage" => Self::CONTAINER_USAGE,
+            "custom_timeseries_percentage" => Self::CUSTOM_TIMESERIES_PERCENTAGE,
+            "container_percentage" => Self::CONTAINER_PERCENTAGE,
+            "apm_host_percentage" => Self::APM_HOST_PERCENTAGE,
+            "npm_host_percentage" => Self::NPM_HOST_PERCENTAGE,
+            "browser_percentage" => Self::BROWSER_PERCENTAGE,
+            "browser_usage" => Self::BROWSER_USAGE,
+            "infra_host_percentage" => Self::INFRA_HOST_PERCENTAGE,
+            "snmp_percentage" => Self::SNMP_PERCENTAGE,
+            "npm_host_usage" => Self::NPM_HOST_USAGE,
+            "infra_host_usage" => Self::INFRA_HOST_USAGE,
+            "custom_timeseries_usage" => Self::CUSTOM_TIMESERIES_USAGE,
+            "lambda_functions_usage" => Self::LAMBDA_FUNCTIONS_USAGE,
+            "lambda_functions_percentage" => Self::LAMBDA_FUNCTIONS_PERCENTAGE,
+            "lambda_invocations_usage" => Self::LAMBDA_INVOCATIONS_USAGE,
+            "lambda_invocations_percentage" => Self::LAMBDA_INVOCATIONS_PERCENTAGE,
+            "estimated_indexed_logs_usage" => Self::ESTIMATED_INDEXED_LOGS_USAGE,
+            "estimated_indexed_logs_percentage" => Self::ESTIMATED_INDEXED_LOGS_PERCENTAGE,
+            "estimated_ingested_logs_usage" => Self::ESTIMATED_INGESTED_LOGS_USAGE,
+            "estimated_ingested_logs_percentage" => Self::ESTIMATED_INGESTED_LOGS_PERCENTAGE,
+            "estimated_indexed_spans_usage" => Self::ESTIMATED_INDEXED_SPANS_USAGE,
+            "estimated_indexed_spans_percentage" => Self::ESTIMATED_INDEXED_SPANS_PERCENTAGE,
+            "estimated_ingested_spans_usage" => Self::ESTIMATED_INGESTED_SPANS_USAGE,
+            "estimated_ingested_spans_percentage" => Self::ESTIMATED_INGESTED_SPANS_PERCENTAGE,
+            "apm_fargate_usage" => Self::APM_FARGATE_USAGE,
+            "apm_fargate_percentage" => Self::APM_FARGATE_PERCENTAGE,
+            "appsec_fargate_usage" => Self::APPSEC_FARGATE_USAGE,
+            "appsec_fargate_percentage" => Self::APPSEC_FARGATE_PERCENTAGE,
+            "estimated_rum_usage_attribution_usage" => Self::ESTIMATED_RUM_USAGE_ATTRIBUTION_USAGE,
+            "estimated_rum_usage_attribution_percentage" => {
+                Self::ESTIMATED_RUM_USAGE_ATTRIBUTION_PERCENTAGE
+            }
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_usage_attribution_supported_metrics.rs b/src/datadogV1/model/model_usage_attribution_supported_metrics.rs
index bc8ff1e63..93a41c407 100644
--- a/src/datadogV1/model/model_usage_attribution_supported_metrics.rs
+++ b/src/datadogV1/model/model_usage_attribution_supported_metrics.rs
@@ -2,104 +2,57 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum UsageAttributionSupportedMetrics {
-    #[serde(rename = "custom_timeseries_usage")]
     CUSTOM_TIMESERIES_USAGE,
-    #[serde(rename = "container_usage")]
     CONTAINER_USAGE,
-    #[serde(rename = "snmp_percentage")]
     SNMP_PERCENTAGE,
-    #[serde(rename = "apm_host_usage")]
     APM_HOST_USAGE,
-    #[serde(rename = "browser_usage")]
     BROWSER_USAGE,
-    #[serde(rename = "npm_host_percentage")]
     NPM_HOST_PERCENTAGE,
-    #[serde(rename = "infra_host_usage")]
     INFRA_HOST_USAGE,
-    #[serde(rename = "custom_timeseries_percentage")]
     CUSTOM_TIMESERIES_PERCENTAGE,
-    #[serde(rename = "container_percentage")]
     CONTAINER_PERCENTAGE,
-    #[serde(rename = "api_usage")]
     API_USAGE,
-    #[serde(rename = "apm_host_percentage")]
     APM_HOST_PERCENTAGE,
-    #[serde(rename = "infra_host_percentage")]
     INFRA_HOST_PERCENTAGE,
-    #[serde(rename = "snmp_usage")]
     SNMP_USAGE,
-    #[serde(rename = "browser_percentage")]
     BROWSER_PERCENTAGE,
-    #[serde(rename = "api_percentage")]
     API_PERCENTAGE,
-    #[serde(rename = "npm_host_usage")]
     NPM_HOST_USAGE,
-    #[serde(rename = "lambda_functions_usage")]
     LAMBDA_FUNCTIONS_USAGE,
-    #[serde(rename = "lambda_functions_percentage")]
     LAMBDA_FUNCTIONS_PERCENTAGE,
-    #[serde(rename = "lambda_invocations_usage")]
     LAMBDA_INVOCATIONS_USAGE,
-    #[serde(rename = "lambda_invocations_percentage")]
     LAMBDA_INVOCATIONS_PERCENTAGE,
-    #[serde(rename = "fargate_usage")]
     FARGATE_USAGE,
-    #[serde(rename = "fargate_percentage")]
     FARGATE_PERCENTAGE,
-    #[serde(rename = "profiled_host_usage")]
     PROFILED_HOST_USAGE,
-    #[serde(rename = "profiled_host_percentage")]
     PROFILED_HOST_PERCENTAGE,
-    #[serde(rename = "profiled_container_usage")]
     PROFILED_CONTAINER_USAGE,
-    #[serde(rename = "profiled_container_percentage")]
     PROFILED_CONTAINER_PERCENTAGE,
-    #[serde(rename = "dbm_hosts_usage")]
     DBM_HOSTS_USAGE,
-    #[serde(rename = "dbm_hosts_percentage")]
     DBM_HOSTS_PERCENTAGE,
-    #[serde(rename = "dbm_queries_usage")]
     DBM_QUERIES_USAGE,
-    #[serde(rename = "dbm_queries_percentage")]
     DBM_QUERIES_PERCENTAGE,
-    #[serde(rename = "estimated_indexed_logs_usage")]
     ESTIMATED_INDEXED_LOGS_USAGE,
-    #[serde(rename = "estimated_indexed_logs_percentage")]
     ESTIMATED_INDEXED_LOGS_PERCENTAGE,
-    #[serde(rename = "estimated_ingested_logs_usage")]
     ESTIMATED_INGESTED_LOGS_USAGE,
-    #[serde(rename = "estimated_ingested_logs_percentage")]
     ESTIMATED_INGESTED_LOGS_PERCENTAGE,
-    #[serde(rename = "appsec_usage")]
     APPSEC_USAGE,
-    #[serde(rename = "appsec_percentage")]
     APPSEC_PERCENTAGE,
-    #[serde(rename = "estimated_indexed_spans_usage")]
     ESTIMATED_INDEXED_SPANS_USAGE,
-    #[serde(rename = "estimated_indexed_spans_percentage")]
     ESTIMATED_INDEXED_SPANS_PERCENTAGE,
-    #[serde(rename = "estimated_ingested_spans_usage")]
     ESTIMATED_INGESTED_SPANS_USAGE,
-    #[serde(rename = "estimated_ingested_spans_percentage")]
     ESTIMATED_INGESTED_SPANS_PERCENTAGE,
-    #[serde(rename = "apm_fargate_usage")]
     APM_FARGATE_USAGE,
-    #[serde(rename = "apm_fargate_percentage")]
     APM_FARGATE_PERCENTAGE,
-    #[serde(rename = "appsec_fargate_usage")]
     APPSEC_FARGATE_USAGE,
-    #[serde(rename = "appsec_fargate_percentage")]
     APPSEC_FARGATE_PERCENTAGE,
-    #[serde(rename = "estimated_rum_usage_attribution_usage")]
     ESTIMATED_RUM_USAGE_ATTRIBUTION_USAGE,
-    #[serde(rename = "estimated_rum_usage_attribution_percentage")]
     ESTIMATED_RUM_USAGE_ATTRIBUTION_PERCENTAGE,
-    #[serde(rename = "*")]
     ALL,
 }
 
@@ -168,3 +121,80 @@ impl ToString for UsageAttributionSupportedMetrics {
         }
     }
 }
+
+impl Serialize for UsageAttributionSupportedMetrics {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for UsageAttributionSupportedMetrics {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "custom_timeseries_usage" => Self::CUSTOM_TIMESERIES_USAGE,
+            "container_usage" => Self::CONTAINER_USAGE,
+            "snmp_percentage" => Self::SNMP_PERCENTAGE,
+            "apm_host_usage" => Self::APM_HOST_USAGE,
+            "browser_usage" => Self::BROWSER_USAGE,
+            "npm_host_percentage" => Self::NPM_HOST_PERCENTAGE,
+            "infra_host_usage" => Self::INFRA_HOST_USAGE,
+            "custom_timeseries_percentage" => Self::CUSTOM_TIMESERIES_PERCENTAGE,
+            "container_percentage" => Self::CONTAINER_PERCENTAGE,
+            "api_usage" => Self::API_USAGE,
+            "apm_host_percentage" => Self::APM_HOST_PERCENTAGE,
+            "infra_host_percentage" => Self::INFRA_HOST_PERCENTAGE,
+            "snmp_usage" => Self::SNMP_USAGE,
+            "browser_percentage" => Self::BROWSER_PERCENTAGE,
+            "api_percentage" => Self::API_PERCENTAGE,
+            "npm_host_usage" => Self::NPM_HOST_USAGE,
+            "lambda_functions_usage" => Self::LAMBDA_FUNCTIONS_USAGE,
+            "lambda_functions_percentage" => Self::LAMBDA_FUNCTIONS_PERCENTAGE,
+            "lambda_invocations_usage" => Self::LAMBDA_INVOCATIONS_USAGE,
+            "lambda_invocations_percentage" => Self::LAMBDA_INVOCATIONS_PERCENTAGE,
+            "fargate_usage" => Self::FARGATE_USAGE,
+            "fargate_percentage" => Self::FARGATE_PERCENTAGE,
+            "profiled_host_usage" => Self::PROFILED_HOST_USAGE,
+            "profiled_host_percentage" => Self::PROFILED_HOST_PERCENTAGE,
+            "profiled_container_usage" => Self::PROFILED_CONTAINER_USAGE,
+            "profiled_container_percentage" => Self::PROFILED_CONTAINER_PERCENTAGE,
+            "dbm_hosts_usage" => Self::DBM_HOSTS_USAGE,
+            "dbm_hosts_percentage" => Self::DBM_HOSTS_PERCENTAGE,
+            "dbm_queries_usage" => Self::DBM_QUERIES_USAGE,
+            "dbm_queries_percentage" => Self::DBM_QUERIES_PERCENTAGE,
+            "estimated_indexed_logs_usage" => Self::ESTIMATED_INDEXED_LOGS_USAGE,
+            "estimated_indexed_logs_percentage" => Self::ESTIMATED_INDEXED_LOGS_PERCENTAGE,
+            "estimated_ingested_logs_usage" => Self::ESTIMATED_INGESTED_LOGS_USAGE,
+            "estimated_ingested_logs_percentage" => Self::ESTIMATED_INGESTED_LOGS_PERCENTAGE,
+            "appsec_usage" => Self::APPSEC_USAGE,
+            "appsec_percentage" => Self::APPSEC_PERCENTAGE,
+            "estimated_indexed_spans_usage" => Self::ESTIMATED_INDEXED_SPANS_USAGE,
+            "estimated_indexed_spans_percentage" => Self::ESTIMATED_INDEXED_SPANS_PERCENTAGE,
+            "estimated_ingested_spans_usage" => Self::ESTIMATED_INGESTED_SPANS_USAGE,
+            "estimated_ingested_spans_percentage" => Self::ESTIMATED_INGESTED_SPANS_PERCENTAGE,
+            "apm_fargate_usage" => Self::APM_FARGATE_USAGE,
+            "apm_fargate_percentage" => Self::APM_FARGATE_PERCENTAGE,
+            "appsec_fargate_usage" => Self::APPSEC_FARGATE_USAGE,
+            "appsec_fargate_percentage" => Self::APPSEC_FARGATE_PERCENTAGE,
+            "estimated_rum_usage_attribution_usage" => Self::ESTIMATED_RUM_USAGE_ATTRIBUTION_USAGE,
+            "estimated_rum_usage_attribution_percentage" => {
+                Self::ESTIMATED_RUM_USAGE_ATTRIBUTION_PERCENTAGE
+            }
+            "*" => Self::ALL,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_usage_metric_category.rs b/src/datadogV1/model/model_usage_metric_category.rs
index 64b4b92ee..aa297b512 100644
--- a/src/datadogV1/model/model_usage_metric_category.rs
+++ b/src/datadogV1/model/model_usage_metric_category.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum UsageMetricCategory {
-    #[serde(rename = "standard")]
     STANDARD,
-    #[serde(rename = "custom")]
     CUSTOM,
 }
 
@@ -21,3 +19,33 @@ impl ToString for UsageMetricCategory {
         }
     }
 }
+
+impl Serialize for UsageMetricCategory {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for UsageMetricCategory {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "standard" => Self::STANDARD,
+            "custom" => Self::CUSTOM,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_usage_reports_type.rs b/src/datadogV1/model/model_usage_reports_type.rs
index f760bef15..ac19663b9 100644
--- a/src/datadogV1/model/model_usage_reports_type.rs
+++ b/src/datadogV1/model/model_usage_reports_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum UsageReportsType {
-    #[serde(rename = "reports")]
     REPORTS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for UsageReportsType {
         }
     }
 }
+
+impl Serialize for UsageReportsType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for UsageReportsType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "reports" => Self::REPORTS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_usage_sort.rs b/src/datadogV1/model/model_usage_sort.rs
index de42ad1a3..a20aba00a 100644
--- a/src/datadogV1/model/model_usage_sort.rs
+++ b/src/datadogV1/model/model_usage_sort.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum UsageSort {
-    #[serde(rename = "computed_on")]
     COMPUTED_ON,
-    #[serde(rename = "size")]
     SIZE,
-    #[serde(rename = "start_date")]
     START_DATE,
-    #[serde(rename = "end_date")]
     END_DATE,
 }
 
@@ -27,3 +23,35 @@ impl ToString for UsageSort {
         }
     }
 }
+
+impl Serialize for UsageSort {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for UsageSort {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "computed_on" => Self::COMPUTED_ON,
+            "size" => Self::SIZE,
+            "start_date" => Self::START_DATE,
+            "end_date" => Self::END_DATE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_usage_sort_direction.rs b/src/datadogV1/model/model_usage_sort_direction.rs
index 4818d7ac1..ddf046ee0 100644
--- a/src/datadogV1/model/model_usage_sort_direction.rs
+++ b/src/datadogV1/model/model_usage_sort_direction.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum UsageSortDirection {
-    #[serde(rename = "desc")]
     DESC,
-    #[serde(rename = "asc")]
     ASC,
 }
 
@@ -21,3 +19,33 @@ impl ToString for UsageSortDirection {
         }
     }
 }
+
+impl Serialize for UsageSortDirection {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for UsageSortDirection {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "desc" => Self::DESC,
+            "asc" => Self::ASC,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_webhooks_integration_encoding.rs b/src/datadogV1/model/model_webhooks_integration_encoding.rs
index 3d9a6e14c..53bd6aad2 100644
--- a/src/datadogV1/model/model_webhooks_integration_encoding.rs
+++ b/src/datadogV1/model/model_webhooks_integration_encoding.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WebhooksIntegrationEncoding {
-    #[serde(rename = "json")]
     JSON,
-    #[serde(rename = "form")]
     FORM,
 }
 
@@ -21,3 +19,33 @@ impl ToString for WebhooksIntegrationEncoding {
         }
     }
 }
+
+impl Serialize for WebhooksIntegrationEncoding {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WebhooksIntegrationEncoding {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "json" => Self::JSON,
+            "form" => Self::FORM,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_aggregator.rs b/src/datadogV1/model/model_widget_aggregator.rs
index ac7b2189b..4402df02a 100644
--- a/src/datadogV1/model/model_widget_aggregator.rs
+++ b/src/datadogV1/model/model_widget_aggregator.rs
@@ -2,22 +2,16 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetAggregator {
-    #[serde(rename = "avg")]
     AVERAGE,
-    #[serde(rename = "last")]
     LAST,
-    #[serde(rename = "max")]
     MAXIMUM,
-    #[serde(rename = "min")]
     MINIMUM,
-    #[serde(rename = "sum")]
     SUM,
-    #[serde(rename = "percentile")]
     PERCENTILE,
 }
 
@@ -33,3 +27,37 @@ impl ToString for WidgetAggregator {
         }
     }
 }
+
+impl Serialize for WidgetAggregator {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetAggregator {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "avg" => Self::AVERAGE,
+            "last" => Self::LAST,
+            "max" => Self::MAXIMUM,
+            "min" => Self::MINIMUM,
+            "sum" => Self::SUM,
+            "percentile" => Self::PERCENTILE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_change_type.rs b/src/datadogV1/model/model_widget_change_type.rs
index d974fe8b9..4b7912763 100644
--- a/src/datadogV1/model/model_widget_change_type.rs
+++ b/src/datadogV1/model/model_widget_change_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetChangeType {
-    #[serde(rename = "absolute")]
     ABSOLUTE,
-    #[serde(rename = "relative")]
     RELATIVE,
 }
 
@@ -21,3 +19,33 @@ impl ToString for WidgetChangeType {
         }
     }
 }
+
+impl Serialize for WidgetChangeType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetChangeType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "absolute" => Self::ABSOLUTE,
+            "relative" => Self::RELATIVE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_color_preference.rs b/src/datadogV1/model/model_widget_color_preference.rs
index 023281765..bf94c19e6 100644
--- a/src/datadogV1/model/model_widget_color_preference.rs
+++ b/src/datadogV1/model/model_widget_color_preference.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetColorPreference {
-    #[serde(rename = "background")]
     BACKGROUND,
-    #[serde(rename = "text")]
     TEXT,
 }
 
@@ -21,3 +19,33 @@ impl ToString for WidgetColorPreference {
         }
     }
 }
+
+impl Serialize for WidgetColorPreference {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetColorPreference {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "background" => Self::BACKGROUND,
+            "text" => Self::TEXT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_comparator.rs b/src/datadogV1/model/model_widget_comparator.rs
index 3f064b39b..a32b64572 100644
--- a/src/datadogV1/model/model_widget_comparator.rs
+++ b/src/datadogV1/model/model_widget_comparator.rs
@@ -2,20 +2,15 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetComparator {
-    #[serde(rename = "=")]
     EQUAL_TO,
-    #[serde(rename = ">")]
     GREATER_THAN,
-    #[serde(rename = ">=")]
     GREATER_THAN_OR_EQUAL_TO,
-    #[serde(rename = "<")]
     LESS_THAN,
-    #[serde(rename = "<=")]
     LESS_THAN_OR_EQUAL_TO,
 }
 
@@ -30,3 +25,36 @@ impl ToString for WidgetComparator {
         }
     }
 }
+
+impl Serialize for WidgetComparator {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetComparator {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "=" => Self::EQUAL_TO,
+            ">" => Self::GREATER_THAN,
+            ">=" => Self::GREATER_THAN_OR_EQUAL_TO,
+            "<" => Self::LESS_THAN,
+            "<=" => Self::LESS_THAN_OR_EQUAL_TO,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_compare_to.rs b/src/datadogV1/model/model_widget_compare_to.rs
index 1c7a84e11..60926510f 100644
--- a/src/datadogV1/model/model_widget_compare_to.rs
+++ b/src/datadogV1/model/model_widget_compare_to.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetCompareTo {
-    #[serde(rename = "hour_before")]
     HOUR_BEFORE,
-    #[serde(rename = "day_before")]
     DAY_BEFORE,
-    #[serde(rename = "week_before")]
     WEEK_BEFORE,
-    #[serde(rename = "month_before")]
     MONTH_BEFORE,
 }
 
@@ -27,3 +23,35 @@ impl ToString for WidgetCompareTo {
         }
     }
 }
+
+impl Serialize for WidgetCompareTo {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetCompareTo {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "hour_before" => Self::HOUR_BEFORE,
+            "day_before" => Self::DAY_BEFORE,
+            "week_before" => Self::WEEK_BEFORE,
+            "month_before" => Self::MONTH_BEFORE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_display_type.rs b/src/datadogV1/model/model_widget_display_type.rs
index 31e35538e..eba8e0b52 100644
--- a/src/datadogV1/model/model_widget_display_type.rs
+++ b/src/datadogV1/model/model_widget_display_type.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetDisplayType {
-    #[serde(rename = "area")]
     AREA,
-    #[serde(rename = "bars")]
     BARS,
-    #[serde(rename = "line")]
     LINE,
-    #[serde(rename = "overlay")]
     OVERLAY,
 }
 
@@ -27,3 +23,35 @@ impl ToString for WidgetDisplayType {
         }
     }
 }
+
+impl Serialize for WidgetDisplayType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetDisplayType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "area" => Self::AREA,
+            "bars" => Self::BARS,
+            "line" => Self::LINE,
+            "overlay" => Self::OVERLAY,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_event_size.rs b/src/datadogV1/model/model_widget_event_size.rs
index f92cd910d..bc72e1741 100644
--- a/src/datadogV1/model/model_widget_event_size.rs
+++ b/src/datadogV1/model/model_widget_event_size.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetEventSize {
-    #[serde(rename = "s")]
     SMALL,
-    #[serde(rename = "l")]
     LARGE,
 }
 
@@ -21,3 +19,33 @@ impl ToString for WidgetEventSize {
         }
     }
 }
+
+impl Serialize for WidgetEventSize {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetEventSize {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "s" => Self::SMALL,
+            "l" => Self::LARGE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_grouping.rs b/src/datadogV1/model/model_widget_grouping.rs
index 02d408a26..512fa92fb 100644
--- a/src/datadogV1/model/model_widget_grouping.rs
+++ b/src/datadogV1/model/model_widget_grouping.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetGrouping {
-    #[serde(rename = "check")]
     CHECK,
-    #[serde(rename = "cluster")]
     CLUSTER,
 }
 
@@ -21,3 +19,33 @@ impl ToString for WidgetGrouping {
         }
     }
 }
+
+impl Serialize for WidgetGrouping {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetGrouping {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "check" => Self::CHECK,
+            "cluster" => Self::CLUSTER,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_horizontal_align.rs b/src/datadogV1/model/model_widget_horizontal_align.rs
index e9b3f7f2f..ba7a161a4 100644
--- a/src/datadogV1/model/model_widget_horizontal_align.rs
+++ b/src/datadogV1/model/model_widget_horizontal_align.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetHorizontalAlign {
-    #[serde(rename = "center")]
     CENTER,
-    #[serde(rename = "left")]
     LEFT,
-    #[serde(rename = "right")]
     RIGHT,
 }
 
@@ -24,3 +21,34 @@ impl ToString for WidgetHorizontalAlign {
         }
     }
 }
+
+impl Serialize for WidgetHorizontalAlign {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetHorizontalAlign {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "center" => Self::CENTER,
+            "left" => Self::LEFT,
+            "right" => Self::RIGHT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_image_sizing.rs b/src/datadogV1/model/model_widget_image_sizing.rs
index 0f42581a7..889a7316c 100644
--- a/src/datadogV1/model/model_widget_image_sizing.rs
+++ b/src/datadogV1/model/model_widget_image_sizing.rs
@@ -2,26 +2,18 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetImageSizing {
-    #[serde(rename = "fill")]
     FILL,
-    #[serde(rename = "contain")]
     CONTAIN,
-    #[serde(rename = "cover")]
     COVER,
-    #[serde(rename = "none")]
     NONE,
-    #[serde(rename = "scale-down")]
     SCALEDOWN,
-    #[serde(rename = "zoom")]
     ZOOM,
-    #[serde(rename = "fit")]
     FIT,
-    #[serde(rename = "center")]
     CENTER,
 }
 
@@ -39,3 +31,39 @@ impl ToString for WidgetImageSizing {
         }
     }
 }
+
+impl Serialize for WidgetImageSizing {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetImageSizing {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "fill" => Self::FILL,
+            "contain" => Self::CONTAIN,
+            "cover" => Self::COVER,
+            "none" => Self::NONE,
+            "scale-down" => Self::SCALEDOWN,
+            "zoom" => Self::ZOOM,
+            "fit" => Self::FIT,
+            "center" => Self::CENTER,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_layout_type.rs b/src/datadogV1/model/model_widget_layout_type.rs
index 9c468e0eb..c73a54d45 100644
--- a/src/datadogV1/model/model_widget_layout_type.rs
+++ b/src/datadogV1/model/model_widget_layout_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetLayoutType {
-    #[serde(rename = "ordered")]
     ORDERED,
 }
 
@@ -18,3 +17,32 @@ impl ToString for WidgetLayoutType {
         }
     }
 }
+
+impl Serialize for WidgetLayoutType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetLayoutType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "ordered" => Self::ORDERED,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_line_type.rs b/src/datadogV1/model/model_widget_line_type.rs
index 12bf201df..3bdcb21d0 100644
--- a/src/datadogV1/model/model_widget_line_type.rs
+++ b/src/datadogV1/model/model_widget_line_type.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetLineType {
-    #[serde(rename = "dashed")]
     DASHED,
-    #[serde(rename = "dotted")]
     DOTTED,
-    #[serde(rename = "solid")]
     SOLID,
 }
 
@@ -24,3 +21,34 @@ impl ToString for WidgetLineType {
         }
     }
 }
+
+impl Serialize for WidgetLineType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetLineType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "dashed" => Self::DASHED,
+            "dotted" => Self::DOTTED,
+            "solid" => Self::SOLID,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_line_width.rs b/src/datadogV1/model/model_widget_line_width.rs
index dd75977ca..f8ceb713b 100644
--- a/src/datadogV1/model/model_widget_line_width.rs
+++ b/src/datadogV1/model/model_widget_line_width.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetLineWidth {
-    #[serde(rename = "normal")]
     NORMAL,
-    #[serde(rename = "thick")]
     THICK,
-    #[serde(rename = "thin")]
     THIN,
 }
 
@@ -24,3 +21,34 @@ impl ToString for WidgetLineWidth {
         }
     }
 }
+
+impl Serialize for WidgetLineWidth {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetLineWidth {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "normal" => Self::NORMAL,
+            "thick" => Self::THICK,
+            "thin" => Self::THIN,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_live_span.rs b/src/datadogV1/model/model_widget_live_span.rs
index 5998859e8..81d0d173f 100644
--- a/src/datadogV1/model/model_widget_live_span.rs
+++ b/src/datadogV1/model/model_widget_live_span.rs
@@ -2,44 +2,27 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetLiveSpan {
-    #[serde(rename = "1m")]
     PAST_ONE_MINUTE,
-    #[serde(rename = "5m")]
     PAST_FIVE_MINUTES,
-    #[serde(rename = "10m")]
     PAST_TEN_MINUTES,
-    #[serde(rename = "15m")]
     PAST_FIFTEEN_MINUTES,
-    #[serde(rename = "30m")]
     PAST_THIRTY_MINUTES,
-    #[serde(rename = "1h")]
     PAST_ONE_HOUR,
-    #[serde(rename = "4h")]
     PAST_FOUR_HOURS,
-    #[serde(rename = "1d")]
     PAST_ONE_DAY,
-    #[serde(rename = "2d")]
     PAST_TWO_DAYS,
-    #[serde(rename = "1w")]
     PAST_ONE_WEEK,
-    #[serde(rename = "1mo")]
     PAST_ONE_MONTH,
-    #[serde(rename = "3mo")]
     PAST_THREE_MONTHS,
-    #[serde(rename = "6mo")]
     PAST_SIX_MONTHS,
-    #[serde(rename = "week_to_date")]
     WEEK_TO_DATE,
-    #[serde(rename = "month_to_date")]
     MONTH_TO_DATE,
-    #[serde(rename = "1y")]
     PAST_ONE_YEAR,
-    #[serde(rename = "alert")]
     ALERT,
 }
 
@@ -66,3 +49,48 @@ impl ToString for WidgetLiveSpan {
         }
     }
 }
+
+impl Serialize for WidgetLiveSpan {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetLiveSpan {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "1m" => Self::PAST_ONE_MINUTE,
+            "5m" => Self::PAST_FIVE_MINUTES,
+            "10m" => Self::PAST_TEN_MINUTES,
+            "15m" => Self::PAST_FIFTEEN_MINUTES,
+            "30m" => Self::PAST_THIRTY_MINUTES,
+            "1h" => Self::PAST_ONE_HOUR,
+            "4h" => Self::PAST_FOUR_HOURS,
+            "1d" => Self::PAST_ONE_DAY,
+            "2d" => Self::PAST_TWO_DAYS,
+            "1w" => Self::PAST_ONE_WEEK,
+            "1mo" => Self::PAST_ONE_MONTH,
+            "3mo" => Self::PAST_THREE_MONTHS,
+            "6mo" => Self::PAST_SIX_MONTHS,
+            "week_to_date" => Self::WEEK_TO_DATE,
+            "month_to_date" => Self::MONTH_TO_DATE,
+            "1y" => Self::PAST_ONE_YEAR,
+            "alert" => Self::ALERT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_margin.rs b/src/datadogV1/model/model_widget_margin.rs
index 646c3bc5f..e77ff6edd 100644
--- a/src/datadogV1/model/model_widget_margin.rs
+++ b/src/datadogV1/model/model_widget_margin.rs
@@ -2,20 +2,15 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetMargin {
-    #[serde(rename = "sm")]
     SM,
-    #[serde(rename = "md")]
     MD,
-    #[serde(rename = "lg")]
     LG,
-    #[serde(rename = "small")]
     SMALL,
-    #[serde(rename = "large")]
     LARGE,
 }
 
@@ -30,3 +25,36 @@ impl ToString for WidgetMargin {
         }
     }
 }
+
+impl Serialize for WidgetMargin {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetMargin {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "sm" => Self::SM,
+            "md" => Self::MD,
+            "lg" => Self::LG,
+            "small" => Self::SMALL,
+            "large" => Self::LARGE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_message_display.rs b/src/datadogV1/model/model_widget_message_display.rs
index b2c6e6d60..3450a646f 100644
--- a/src/datadogV1/model/model_widget_message_display.rs
+++ b/src/datadogV1/model/model_widget_message_display.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetMessageDisplay {
-    #[serde(rename = "inline")]
     INLINE,
-    #[serde(rename = "expanded-md")]
     EXPANDED_MEDIUM,
-    #[serde(rename = "expanded-lg")]
     EXPANDED_LARGE,
 }
 
@@ -24,3 +21,34 @@ impl ToString for WidgetMessageDisplay {
         }
     }
 }
+
+impl Serialize for WidgetMessageDisplay {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetMessageDisplay {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "inline" => Self::INLINE,
+            "expanded-md" => Self::EXPANDED_MEDIUM,
+            "expanded-lg" => Self::EXPANDED_LARGE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_monitor_summary_display_format.rs b/src/datadogV1/model/model_widget_monitor_summary_display_format.rs
index 4aa857d22..7efa02958 100644
--- a/src/datadogV1/model/model_widget_monitor_summary_display_format.rs
+++ b/src/datadogV1/model/model_widget_monitor_summary_display_format.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetMonitorSummaryDisplayFormat {
-    #[serde(rename = "counts")]
     COUNTS,
-    #[serde(rename = "countsAndList")]
     COUNTS_AND_LIST,
-    #[serde(rename = "list")]
     LIST,
 }
 
@@ -24,3 +21,34 @@ impl ToString for WidgetMonitorSummaryDisplayFormat {
         }
     }
 }
+
+impl Serialize for WidgetMonitorSummaryDisplayFormat {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetMonitorSummaryDisplayFormat {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "counts" => Self::COUNTS,
+            "countsAndList" => Self::COUNTS_AND_LIST,
+            "list" => Self::LIST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_monitor_summary_sort.rs b/src/datadogV1/model/model_widget_monitor_summary_sort.rs
index 6b0c335d1..c1a02120d 100644
--- a/src/datadogV1/model/model_widget_monitor_summary_sort.rs
+++ b/src/datadogV1/model/model_widget_monitor_summary_sort.rs
@@ -2,44 +2,27 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetMonitorSummarySort {
-    #[serde(rename = "name")]
     NAME,
-    #[serde(rename = "group")]
     GROUP,
-    #[serde(rename = "status")]
     STATUS,
-    #[serde(rename = "tags")]
     TAGS,
-    #[serde(rename = "triggered")]
     TRIGGERED,
-    #[serde(rename = "group,asc")]
     GROUP_ASCENDING,
-    #[serde(rename = "group,desc")]
     GROUP_DESCENDING,
-    #[serde(rename = "name,asc")]
     NAME_ASCENDING,
-    #[serde(rename = "name,desc")]
     NAME_DESCENDING,
-    #[serde(rename = "status,asc")]
     STATUS_ASCENDING,
-    #[serde(rename = "status,desc")]
     STATUS_DESCENDING,
-    #[serde(rename = "tags,asc")]
     TAGS_ASCENDING,
-    #[serde(rename = "tags,desc")]
     TAGS_DESCENDING,
-    #[serde(rename = "triggered,asc")]
     TRIGGERED_ASCENDING,
-    #[serde(rename = "triggered,desc")]
     TRIGGERED_DESCENDING,
-    #[serde(rename = "priority,asc")]
     PRIORITY_ASCENDING,
-    #[serde(rename = "priority,desc")]
     PRIORITY_DESCENDING,
 }
 
@@ -66,3 +49,48 @@ impl ToString for WidgetMonitorSummarySort {
         }
     }
 }
+
+impl Serialize for WidgetMonitorSummarySort {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetMonitorSummarySort {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "name" => Self::NAME,
+            "group" => Self::GROUP,
+            "status" => Self::STATUS,
+            "tags" => Self::TAGS,
+            "triggered" => Self::TRIGGERED,
+            "group,asc" => Self::GROUP_ASCENDING,
+            "group,desc" => Self::GROUP_DESCENDING,
+            "name,asc" => Self::NAME_ASCENDING,
+            "name,desc" => Self::NAME_DESCENDING,
+            "status,asc" => Self::STATUS_ASCENDING,
+            "status,desc" => Self::STATUS_DESCENDING,
+            "tags,asc" => Self::TAGS_ASCENDING,
+            "tags,desc" => Self::TAGS_DESCENDING,
+            "triggered,asc" => Self::TRIGGERED_ASCENDING,
+            "triggered,desc" => Self::TRIGGERED_DESCENDING,
+            "priority,asc" => Self::PRIORITY_ASCENDING,
+            "priority,desc" => Self::PRIORITY_DESCENDING,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_node_type.rs b/src/datadogV1/model/model_widget_node_type.rs
index f2145af4a..cb4f00d51 100644
--- a/src/datadogV1/model/model_widget_node_type.rs
+++ b/src/datadogV1/model/model_widget_node_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetNodeType {
-    #[serde(rename = "host")]
     HOST,
-    #[serde(rename = "container")]
     CONTAINER,
 }
 
@@ -21,3 +19,33 @@ impl ToString for WidgetNodeType {
         }
     }
 }
+
+impl Serialize for WidgetNodeType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetNodeType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "host" => Self::HOST,
+            "container" => Self::CONTAINER,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_order_by.rs b/src/datadogV1/model/model_widget_order_by.rs
index b9b9892a9..0a6c1a770 100644
--- a/src/datadogV1/model/model_widget_order_by.rs
+++ b/src/datadogV1/model/model_widget_order_by.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetOrderBy {
-    #[serde(rename = "change")]
     CHANGE,
-    #[serde(rename = "name")]
     NAME,
-    #[serde(rename = "present")]
     PRESENT,
-    #[serde(rename = "past")]
     PAST,
 }
 
@@ -27,3 +23,35 @@ impl ToString for WidgetOrderBy {
         }
     }
 }
+
+impl Serialize for WidgetOrderBy {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetOrderBy {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "change" => Self::CHANGE,
+            "name" => Self::NAME,
+            "present" => Self::PRESENT,
+            "past" => Self::PAST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_palette.rs b/src/datadogV1/model/model_widget_palette.rs
index cc8ec89b7..6f0c4b075 100644
--- a/src/datadogV1/model/model_widget_palette.rs
+++ b/src/datadogV1/model/model_widget_palette.rs
@@ -2,48 +2,29 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetPalette {
-    #[serde(rename = "blue")]
     BLUE,
-    #[serde(rename = "custom_bg")]
     CUSTOM_BACKGROUND,
-    #[serde(rename = "custom_image")]
     CUSTOM_IMAGE,
-    #[serde(rename = "custom_text")]
     CUSTOM_TEXT,
-    #[serde(rename = "gray_on_white")]
     GRAY_ON_WHITE,
-    #[serde(rename = "grey")]
     GREY,
-    #[serde(rename = "green")]
     GREEN,
-    #[serde(rename = "orange")]
     ORANGE,
-    #[serde(rename = "red")]
     RED,
-    #[serde(rename = "red_on_white")]
     RED_ON_WHITE,
-    #[serde(rename = "white_on_gray")]
     WHITE_ON_GRAY,
-    #[serde(rename = "white_on_green")]
     WHITE_ON_GREEN,
-    #[serde(rename = "green_on_white")]
     GREEN_ON_WHITE,
-    #[serde(rename = "white_on_red")]
     WHITE_ON_RED,
-    #[serde(rename = "white_on_yellow")]
     WHITE_ON_YELLOW,
-    #[serde(rename = "yellow_on_white")]
     YELLOW_ON_WHITE,
-    #[serde(rename = "black_on_light_yellow")]
     BLACK_ON_LIGHT_YELLOW,
-    #[serde(rename = "black_on_light_green")]
     BLACK_ON_LIGHT_GREEN,
-    #[serde(rename = "black_on_light_red")]
     BLACK_ON_LIGHT_RED,
 }
 
@@ -72,3 +53,50 @@ impl ToString for WidgetPalette {
         }
     }
 }
+
+impl Serialize for WidgetPalette {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetPalette {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "blue" => Self::BLUE,
+            "custom_bg" => Self::CUSTOM_BACKGROUND,
+            "custom_image" => Self::CUSTOM_IMAGE,
+            "custom_text" => Self::CUSTOM_TEXT,
+            "gray_on_white" => Self::GRAY_ON_WHITE,
+            "grey" => Self::GREY,
+            "green" => Self::GREEN,
+            "orange" => Self::ORANGE,
+            "red" => Self::RED,
+            "red_on_white" => Self::RED_ON_WHITE,
+            "white_on_gray" => Self::WHITE_ON_GRAY,
+            "white_on_green" => Self::WHITE_ON_GREEN,
+            "green_on_white" => Self::GREEN_ON_WHITE,
+            "white_on_red" => Self::WHITE_ON_RED,
+            "white_on_yellow" => Self::WHITE_ON_YELLOW,
+            "yellow_on_white" => Self::YELLOW_ON_WHITE,
+            "black_on_light_yellow" => Self::BLACK_ON_LIGHT_YELLOW,
+            "black_on_light_green" => Self::BLACK_ON_LIGHT_GREEN,
+            "black_on_light_red" => Self::BLACK_ON_LIGHT_RED,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_service_summary_display_format.rs b/src/datadogV1/model/model_widget_service_summary_display_format.rs
index 77ec5c86f..4bed9b2db 100644
--- a/src/datadogV1/model/model_widget_service_summary_display_format.rs
+++ b/src/datadogV1/model/model_widget_service_summary_display_format.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetServiceSummaryDisplayFormat {
-    #[serde(rename = "one_column")]
     ONE_COLUMN,
-    #[serde(rename = "two_column")]
     TWO_COLUMN,
-    #[serde(rename = "three_column")]
     THREE_COLUMN,
 }
 
@@ -24,3 +21,34 @@ impl ToString for WidgetServiceSummaryDisplayFormat {
         }
     }
 }
+
+impl Serialize for WidgetServiceSummaryDisplayFormat {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetServiceSummaryDisplayFormat {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "one_column" => Self::ONE_COLUMN,
+            "two_column" => Self::TWO_COLUMN,
+            "three_column" => Self::THREE_COLUMN,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_size_format.rs b/src/datadogV1/model/model_widget_size_format.rs
index 3edea5434..b11bc78ec 100644
--- a/src/datadogV1/model/model_widget_size_format.rs
+++ b/src/datadogV1/model/model_widget_size_format.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetSizeFormat {
-    #[serde(rename = "small")]
     SMALL,
-    #[serde(rename = "medium")]
     MEDIUM,
-    #[serde(rename = "large")]
     LARGE,
 }
 
@@ -24,3 +21,34 @@ impl ToString for WidgetSizeFormat {
         }
     }
 }
+
+impl Serialize for WidgetSizeFormat {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetSizeFormat {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "small" => Self::SMALL,
+            "medium" => Self::MEDIUM,
+            "large" => Self::LARGE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_sort.rs b/src/datadogV1/model/model_widget_sort.rs
index 74e412279..670378cd8 100644
--- a/src/datadogV1/model/model_widget_sort.rs
+++ b/src/datadogV1/model/model_widget_sort.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetSort {
-    #[serde(rename = "asc")]
     ASCENDING,
-    #[serde(rename = "desc")]
     DESCENDING,
 }
 
@@ -21,3 +19,33 @@ impl ToString for WidgetSort {
         }
     }
 }
+
+impl Serialize for WidgetSort {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetSort {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "asc" => Self::ASCENDING,
+            "desc" => Self::DESCENDING,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_summary_type.rs b/src/datadogV1/model/model_widget_summary_type.rs
index 7f17bc2ed..c05341d58 100644
--- a/src/datadogV1/model/model_widget_summary_type.rs
+++ b/src/datadogV1/model/model_widget_summary_type.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetSummaryType {
-    #[serde(rename = "monitors")]
     MONITORS,
-    #[serde(rename = "groups")]
     GROUPS,
-    #[serde(rename = "combined")]
     COMBINED,
 }
 
@@ -24,3 +21,34 @@ impl ToString for WidgetSummaryType {
         }
     }
 }
+
+impl Serialize for WidgetSummaryType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetSummaryType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "monitors" => Self::MONITORS,
+            "groups" => Self::GROUPS,
+            "combined" => Self::COMBINED,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_text_align.rs b/src/datadogV1/model/model_widget_text_align.rs
index 97aef9c5b..dc7c9d1e7 100644
--- a/src/datadogV1/model/model_widget_text_align.rs
+++ b/src/datadogV1/model/model_widget_text_align.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetTextAlign {
-    #[serde(rename = "center")]
     CENTER,
-    #[serde(rename = "left")]
     LEFT,
-    #[serde(rename = "right")]
     RIGHT,
 }
 
@@ -24,3 +21,34 @@ impl ToString for WidgetTextAlign {
         }
     }
 }
+
+impl Serialize for WidgetTextAlign {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetTextAlign {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "center" => Self::CENTER,
+            "left" => Self::LEFT,
+            "right" => Self::RIGHT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_tick_edge.rs b/src/datadogV1/model/model_widget_tick_edge.rs
index 25a52958d..e38f279aa 100644
--- a/src/datadogV1/model/model_widget_tick_edge.rs
+++ b/src/datadogV1/model/model_widget_tick_edge.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetTickEdge {
-    #[serde(rename = "bottom")]
     BOTTOM,
-    #[serde(rename = "left")]
     LEFT,
-    #[serde(rename = "right")]
     RIGHT,
-    #[serde(rename = "top")]
     TOP,
 }
 
@@ -27,3 +23,35 @@ impl ToString for WidgetTickEdge {
         }
     }
 }
+
+impl Serialize for WidgetTickEdge {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetTickEdge {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "bottom" => Self::BOTTOM,
+            "left" => Self::LEFT,
+            "right" => Self::RIGHT,
+            "top" => Self::TOP,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_time_windows.rs b/src/datadogV1/model/model_widget_time_windows.rs
index 065e6c38d..78ef5c6d3 100644
--- a/src/datadogV1/model/model_widget_time_windows.rs
+++ b/src/datadogV1/model/model_widget_time_windows.rs
@@ -2,26 +2,18 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetTimeWindows {
-    #[serde(rename = "7d")]
     SEVEN_DAYS,
-    #[serde(rename = "30d")]
     THIRTY_DAYS,
-    #[serde(rename = "90d")]
     NINETY_DAYS,
-    #[serde(rename = "week_to_date")]
     WEEK_TO_DATE,
-    #[serde(rename = "previous_week")]
     PREVIOUS_WEEK,
-    #[serde(rename = "month_to_date")]
     MONTH_TO_DATE,
-    #[serde(rename = "previous_month")]
     PREVIOUS_MONTH,
-    #[serde(rename = "global_time")]
     GLOBAL_TIME,
 }
 
@@ -39,3 +31,39 @@ impl ToString for WidgetTimeWindows {
         }
     }
 }
+
+impl Serialize for WidgetTimeWindows {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetTimeWindows {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "7d" => Self::SEVEN_DAYS,
+            "30d" => Self::THIRTY_DAYS,
+            "90d" => Self::NINETY_DAYS,
+            "week_to_date" => Self::WEEK_TO_DATE,
+            "previous_week" => Self::PREVIOUS_WEEK,
+            "month_to_date" => Self::MONTH_TO_DATE,
+            "previous_month" => Self::PREVIOUS_MONTH,
+            "global_time" => Self::GLOBAL_TIME,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_vertical_align.rs b/src/datadogV1/model/model_widget_vertical_align.rs
index 4a82597ae..ab6edc4d7 100644
--- a/src/datadogV1/model/model_widget_vertical_align.rs
+++ b/src/datadogV1/model/model_widget_vertical_align.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetVerticalAlign {
-    #[serde(rename = "center")]
     CENTER,
-    #[serde(rename = "top")]
     TOP,
-    #[serde(rename = "bottom")]
     BOTTOM,
 }
 
@@ -24,3 +21,34 @@ impl ToString for WidgetVerticalAlign {
         }
     }
 }
+
+impl Serialize for WidgetVerticalAlign {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetVerticalAlign {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "center" => Self::CENTER,
+            "top" => Self::TOP,
+            "bottom" => Self::BOTTOM,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_view_mode.rs b/src/datadogV1/model/model_widget_view_mode.rs
index c6fc08520..e0bd1a498 100644
--- a/src/datadogV1/model/model_widget_view_mode.rs
+++ b/src/datadogV1/model/model_widget_view_mode.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetViewMode {
-    #[serde(rename = "overall")]
     OVERALL,
-    #[serde(rename = "component")]
     COMPONENT,
-    #[serde(rename = "both")]
     BOTH,
 }
 
@@ -24,3 +21,34 @@ impl ToString for WidgetViewMode {
         }
     }
 }
+
+impl Serialize for WidgetViewMode {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetViewMode {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "overall" => Self::OVERALL,
+            "component" => Self::COMPONENT,
+            "both" => Self::BOTH,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV1/model/model_widget_viz_type.rs b/src/datadogV1/model/model_widget_viz_type.rs
index 050392806..350525aa7 100644
--- a/src/datadogV1/model/model_widget_viz_type.rs
+++ b/src/datadogV1/model/model_widget_viz_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetVizType {
-    #[serde(rename = "timeseries")]
     TIMESERIES,
-    #[serde(rename = "toplist")]
     TOPLIST,
 }
 
@@ -21,3 +19,33 @@ impl ToString for WidgetVizType {
         }
     }
 }
+
+impl Serialize for WidgetVizType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetVizType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "timeseries" => Self::TIMESERIES,
+            "toplist" => Self::TOPLIST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_active_billing_dimensions_type.rs b/src/datadogV2/model/model_active_billing_dimensions_type.rs
index 3f8e22b3c..89c300e25 100644
--- a/src/datadogV2/model/model_active_billing_dimensions_type.rs
+++ b/src/datadogV2/model/model_active_billing_dimensions_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ActiveBillingDimensionsType {
-    #[serde(rename = "billing_dimensions")]
     BILLING_DIMENSIONS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ActiveBillingDimensionsType {
         }
     }
 }
+
+impl Serialize for ActiveBillingDimensionsType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ActiveBillingDimensionsType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "billing_dimensions" => Self::BILLING_DIMENSIONS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_api_keys_sort.rs b/src/datadogV2/model/model_api_keys_sort.rs
index a693c8766..25bfba3c2 100644
--- a/src/datadogV2/model/model_api_keys_sort.rs
+++ b/src/datadogV2/model/model_api_keys_sort.rs
@@ -2,26 +2,18 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum APIKeysSort {
-    #[serde(rename = "created_at")]
     CREATED_AT_ASCENDING,
-    #[serde(rename = "-created_at")]
     CREATED_AT_DESCENDING,
-    #[serde(rename = "last4")]
     LAST4_ASCENDING,
-    #[serde(rename = "-last4")]
     LAST4_DESCENDING,
-    #[serde(rename = "modified_at")]
     MODIFIED_AT_ASCENDING,
-    #[serde(rename = "-modified_at")]
     MODIFIED_AT_DESCENDING,
-    #[serde(rename = "name")]
     NAME_ASCENDING,
-    #[serde(rename = "-name")]
     NAME_DESCENDING,
 }
 
@@ -39,3 +31,39 @@ impl ToString for APIKeysSort {
         }
     }
 }
+
+impl Serialize for APIKeysSort {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for APIKeysSort {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "created_at" => Self::CREATED_AT_ASCENDING,
+            "-created_at" => Self::CREATED_AT_DESCENDING,
+            "last4" => Self::LAST4_ASCENDING,
+            "-last4" => Self::LAST4_DESCENDING,
+            "modified_at" => Self::MODIFIED_AT_ASCENDING,
+            "-modified_at" => Self::MODIFIED_AT_DESCENDING,
+            "name" => Self::NAME_ASCENDING,
+            "-name" => Self::NAME_DESCENDING,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_api_keys_type.rs b/src/datadogV2/model/model_api_keys_type.rs
index ae15a8726..f2a5ae7e5 100644
--- a/src/datadogV2/model/model_api_keys_type.rs
+++ b/src/datadogV2/model/model_api_keys_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum APIKeysType {
-    #[serde(rename = "api_keys")]
     API_KEYS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for APIKeysType {
         }
     }
 }
+
+impl Serialize for APIKeysType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for APIKeysType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "api_keys" => Self::API_KEYS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_apm_retention_filter_type.rs b/src/datadogV2/model/model_apm_retention_filter_type.rs
index 2cf598406..e6df09038 100644
--- a/src/datadogV2/model/model_apm_retention_filter_type.rs
+++ b/src/datadogV2/model/model_apm_retention_filter_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ApmRetentionFilterType {
-    #[serde(rename = "apm_retention_filter")]
     apm_retention_filter,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ApmRetentionFilterType {
         }
     }
 }
+
+impl Serialize for ApmRetentionFilterType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ApmRetentionFilterType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "apm_retention_filter" => Self::apm_retention_filter,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_application_keys_sort.rs b/src/datadogV2/model/model_application_keys_sort.rs
index ee3c8c2f6..7b61fb45e 100644
--- a/src/datadogV2/model/model_application_keys_sort.rs
+++ b/src/datadogV2/model/model_application_keys_sort.rs
@@ -2,22 +2,16 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ApplicationKeysSort {
-    #[serde(rename = "created_at")]
     CREATED_AT_ASCENDING,
-    #[serde(rename = "-created_at")]
     CREATED_AT_DESCENDING,
-    #[serde(rename = "last4")]
     LAST4_ASCENDING,
-    #[serde(rename = "-last4")]
     LAST4_DESCENDING,
-    #[serde(rename = "name")]
     NAME_ASCENDING,
-    #[serde(rename = "-name")]
     NAME_DESCENDING,
 }
 
@@ -33,3 +27,37 @@ impl ToString for ApplicationKeysSort {
         }
     }
 }
+
+impl Serialize for ApplicationKeysSort {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ApplicationKeysSort {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "created_at" => Self::CREATED_AT_ASCENDING,
+            "-created_at" => Self::CREATED_AT_DESCENDING,
+            "last4" => Self::LAST4_ASCENDING,
+            "-last4" => Self::LAST4_DESCENDING,
+            "name" => Self::NAME_ASCENDING,
+            "-name" => Self::NAME_DESCENDING,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_application_keys_type.rs b/src/datadogV2/model/model_application_keys_type.rs
index 93ebb6c50..e9af9956c 100644
--- a/src/datadogV2/model/model_application_keys_type.rs
+++ b/src/datadogV2/model/model_application_keys_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ApplicationKeysType {
-    #[serde(rename = "application_keys")]
     APPLICATION_KEYS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ApplicationKeysType {
         }
     }
 }
+
+impl Serialize for ApplicationKeysType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ApplicationKeysType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "application_keys" => Self::APPLICATION_KEYS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_audit_logs_event_type.rs b/src/datadogV2/model/model_audit_logs_event_type.rs
index 43d3e57a8..1bff6ed38 100644
--- a/src/datadogV2/model/model_audit_logs_event_type.rs
+++ b/src/datadogV2/model/model_audit_logs_event_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum AuditLogsEventType {
-    #[serde(rename = "audit")]
     Audit,
 }
 
@@ -18,3 +17,32 @@ impl ToString for AuditLogsEventType {
         }
     }
 }
+
+impl Serialize for AuditLogsEventType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for AuditLogsEventType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "audit" => Self::Audit,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_audit_logs_response_status.rs b/src/datadogV2/model/model_audit_logs_response_status.rs
index f7158fa90..f033bb9bf 100644
--- a/src/datadogV2/model/model_audit_logs_response_status.rs
+++ b/src/datadogV2/model/model_audit_logs_response_status.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum AuditLogsResponseStatus {
-    #[serde(rename = "done")]
     DONE,
-    #[serde(rename = "timeout")]
     TIMEOUT,
 }
 
@@ -21,3 +19,33 @@ impl ToString for AuditLogsResponseStatus {
         }
     }
 }
+
+impl Serialize for AuditLogsResponseStatus {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for AuditLogsResponseStatus {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "done" => Self::DONE,
+            "timeout" => Self::TIMEOUT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_audit_logs_sort.rs b/src/datadogV2/model/model_audit_logs_sort.rs
index 97f2de61b..fd548ad51 100644
--- a/src/datadogV2/model/model_audit_logs_sort.rs
+++ b/src/datadogV2/model/model_audit_logs_sort.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum AuditLogsSort {
-    #[serde(rename = "timestamp")]
     TIMESTAMP_ASCENDING,
-    #[serde(rename = "-timestamp")]
     TIMESTAMP_DESCENDING,
 }
 
@@ -21,3 +19,33 @@ impl ToString for AuditLogsSort {
         }
     }
 }
+
+impl Serialize for AuditLogsSort {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for AuditLogsSort {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "timestamp" => Self::TIMESTAMP_ASCENDING,
+            "-timestamp" => Self::TIMESTAMP_DESCENDING,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_authn_mappings_sort.rs b/src/datadogV2/model/model_authn_mappings_sort.rs
index 229fabb27..72a92d288 100644
--- a/src/datadogV2/model/model_authn_mappings_sort.rs
+++ b/src/datadogV2/model/model_authn_mappings_sort.rs
@@ -2,34 +2,22 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum AuthNMappingsSort {
-    #[serde(rename = "created_at")]
     CREATED_AT_ASCENDING,
-    #[serde(rename = "-created_at")]
     CREATED_AT_DESCENDING,
-    #[serde(rename = "role_id")]
     ROLE_ID_ASCENDING,
-    #[serde(rename = "-role_id")]
     ROLE_ID_DESCENDING,
-    #[serde(rename = "saml_assertion_attribute_id")]
     SAML_ASSERTION_ATTRIBUTE_ID_ASCENDING,
-    #[serde(rename = "-saml_assertion_attribute_id")]
     SAML_ASSERTION_ATTRIBUTE_ID_DESCENDING,
-    #[serde(rename = "role.name")]
     ROLE_NAME_ASCENDING,
-    #[serde(rename = "-role.name")]
     ROLE_NAME_DESCENDING,
-    #[serde(rename = "saml_assertion_attribute.attribute_key")]
     SAML_ASSERTION_ATTRIBUTE_KEY_ASCENDING,
-    #[serde(rename = "-saml_assertion_attribute.attribute_key")]
     SAML_ASSERTION_ATTRIBUTE_KEY_DESCENDING,
-    #[serde(rename = "saml_assertion_attribute.attribute_value")]
     SAML_ASSERTION_ATTRIBUTE_VALUE_ASCENDING,
-    #[serde(rename = "-saml_assertion_attribute.attribute_value")]
     SAML_ASSERTION_ATTRIBUTE_VALUE_DESCENDING,
 }
 
@@ -63,3 +51,51 @@ impl ToString for AuthNMappingsSort {
         }
     }
 }
+
+impl Serialize for AuthNMappingsSort {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for AuthNMappingsSort {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "created_at" => Self::CREATED_AT_ASCENDING,
+            "-created_at" => Self::CREATED_AT_DESCENDING,
+            "role_id" => Self::ROLE_ID_ASCENDING,
+            "-role_id" => Self::ROLE_ID_DESCENDING,
+            "saml_assertion_attribute_id" => Self::SAML_ASSERTION_ATTRIBUTE_ID_ASCENDING,
+            "-saml_assertion_attribute_id" => Self::SAML_ASSERTION_ATTRIBUTE_ID_DESCENDING,
+            "role.name" => Self::ROLE_NAME_ASCENDING,
+            "-role.name" => Self::ROLE_NAME_DESCENDING,
+            "saml_assertion_attribute.attribute_key" => {
+                Self::SAML_ASSERTION_ATTRIBUTE_KEY_ASCENDING
+            }
+            "-saml_assertion_attribute.attribute_key" => {
+                Self::SAML_ASSERTION_ATTRIBUTE_KEY_DESCENDING
+            }
+            "saml_assertion_attribute.attribute_value" => {
+                Self::SAML_ASSERTION_ATTRIBUTE_VALUE_ASCENDING
+            }
+            "-saml_assertion_attribute.attribute_value" => {
+                Self::SAML_ASSERTION_ATTRIBUTE_VALUE_DESCENDING
+            }
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_authn_mappings_type.rs b/src/datadogV2/model/model_authn_mappings_type.rs
index b3f29d924..23c9b3ba8 100644
--- a/src/datadogV2/model/model_authn_mappings_type.rs
+++ b/src/datadogV2/model/model_authn_mappings_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum AuthNMappingsType {
-    #[serde(rename = "authn_mappings")]
     AUTHN_MAPPINGS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for AuthNMappingsType {
         }
     }
 }
+
+impl Serialize for AuthNMappingsType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for AuthNMappingsType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "authn_mappings" => Self::AUTHN_MAPPINGS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_aws_cur_config_patch_request_type.rs b/src/datadogV2/model/model_aws_cur_config_patch_request_type.rs
index 158d4e311..3c7bc59af 100644
--- a/src/datadogV2/model/model_aws_cur_config_patch_request_type.rs
+++ b/src/datadogV2/model/model_aws_cur_config_patch_request_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum AwsCURConfigPatchRequestType {
-    #[serde(rename = "aws_cur_config_patch_request")]
     AWS_CUR_CONFIG_PATCH_REQUEST,
 }
 
@@ -18,3 +17,32 @@ impl ToString for AwsCURConfigPatchRequestType {
         }
     }
 }
+
+impl Serialize for AwsCURConfigPatchRequestType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for AwsCURConfigPatchRequestType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "aws_cur_config_patch_request" => Self::AWS_CUR_CONFIG_PATCH_REQUEST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_aws_cur_config_post_request_type.rs b/src/datadogV2/model/model_aws_cur_config_post_request_type.rs
index df59555f3..0237eafcc 100644
--- a/src/datadogV2/model/model_aws_cur_config_post_request_type.rs
+++ b/src/datadogV2/model/model_aws_cur_config_post_request_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum AwsCURConfigPostRequestType {
-    #[serde(rename = "aws_cur_config_post_request")]
     AWS_CUR_CONFIG_POST_REQUEST,
 }
 
@@ -18,3 +17,32 @@ impl ToString for AwsCURConfigPostRequestType {
         }
     }
 }
+
+impl Serialize for AwsCURConfigPostRequestType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for AwsCURConfigPostRequestType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "aws_cur_config_post_request" => Self::AWS_CUR_CONFIG_POST_REQUEST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_aws_cur_config_type.rs b/src/datadogV2/model/model_aws_cur_config_type.rs
index e19a8bef6..eb9180fec 100644
--- a/src/datadogV2/model/model_aws_cur_config_type.rs
+++ b/src/datadogV2/model/model_aws_cur_config_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum AwsCURConfigType {
-    #[serde(rename = "aws_cur_config")]
     AWS_CUR_CONFIG,
 }
 
@@ -18,3 +17,32 @@ impl ToString for AwsCURConfigType {
         }
     }
 }
+
+impl Serialize for AwsCURConfigType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for AwsCURConfigType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "aws_cur_config" => Self::AWS_CUR_CONFIG,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_aws_related_account_type.rs b/src/datadogV2/model/model_aws_related_account_type.rs
index fb3546ca7..d04816c29 100644
--- a/src/datadogV2/model/model_aws_related_account_type.rs
+++ b/src/datadogV2/model/model_aws_related_account_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum AWSRelatedAccountType {
-    #[serde(rename = "aws_account")]
     AWS_ACCOUNT,
 }
 
@@ -18,3 +17,32 @@ impl ToString for AWSRelatedAccountType {
         }
     }
 }
+
+impl Serialize for AWSRelatedAccountType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for AWSRelatedAccountType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "aws_account" => Self::AWS_ACCOUNT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_azure_uc_config_pair_type.rs b/src/datadogV2/model/model_azure_uc_config_pair_type.rs
index 288ff9323..06e95dfcd 100644
--- a/src/datadogV2/model/model_azure_uc_config_pair_type.rs
+++ b/src/datadogV2/model/model_azure_uc_config_pair_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum AzureUCConfigPairType {
-    #[serde(rename = "azure_uc_configs")]
     AZURE_UC_CONFIGS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for AzureUCConfigPairType {
         }
     }
 }
+
+impl Serialize for AzureUCConfigPairType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for AzureUCConfigPairType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "azure_uc_configs" => Self::AZURE_UC_CONFIGS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_azure_uc_config_patch_request_type.rs b/src/datadogV2/model/model_azure_uc_config_patch_request_type.rs
index 0715efca2..4926cf6c0 100644
--- a/src/datadogV2/model/model_azure_uc_config_patch_request_type.rs
+++ b/src/datadogV2/model/model_azure_uc_config_patch_request_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum AzureUCConfigPatchRequestType {
-    #[serde(rename = "azure_uc_config_patch_request")]
     AZURE_UC_CONFIG_PATCH_REQUEST,
 }
 
@@ -18,3 +17,32 @@ impl ToString for AzureUCConfigPatchRequestType {
         }
     }
 }
+
+impl Serialize for AzureUCConfigPatchRequestType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for AzureUCConfigPatchRequestType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "azure_uc_config_patch_request" => Self::AZURE_UC_CONFIG_PATCH_REQUEST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_azure_uc_config_post_request_type.rs b/src/datadogV2/model/model_azure_uc_config_post_request_type.rs
index 4a3fce27d..cf730e178 100644
--- a/src/datadogV2/model/model_azure_uc_config_post_request_type.rs
+++ b/src/datadogV2/model/model_azure_uc_config_post_request_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum AzureUCConfigPostRequestType {
-    #[serde(rename = "azure_uc_config_post_request")]
     AZURE_UC_CONFIG_POST_REQUEST,
 }
 
@@ -18,3 +17,32 @@ impl ToString for AzureUCConfigPostRequestType {
         }
     }
 }
+
+impl Serialize for AzureUCConfigPostRequestType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for AzureUCConfigPostRequestType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "azure_uc_config_post_request" => Self::AZURE_UC_CONFIG_POST_REQUEST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_ci_app_aggregate_sort_type.rs b/src/datadogV2/model/model_ci_app_aggregate_sort_type.rs
index 0d88b9dcd..1dac241c1 100644
--- a/src/datadogV2/model/model_ci_app_aggregate_sort_type.rs
+++ b/src/datadogV2/model/model_ci_app_aggregate_sort_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CIAppAggregateSortType {
-    #[serde(rename = "alphabetical")]
     ALPHABETICAL,
-    #[serde(rename = "measure")]
     MEASURE,
 }
 
@@ -21,3 +19,33 @@ impl ToString for CIAppAggregateSortType {
         }
     }
 }
+
+impl Serialize for CIAppAggregateSortType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CIAppAggregateSortType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "alphabetical" => Self::ALPHABETICAL,
+            "measure" => Self::MEASURE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_ci_app_aggregation_function.rs b/src/datadogV2/model/model_ci_app_aggregation_function.rs
index a918ab1b3..bab9024a0 100644
--- a/src/datadogV2/model/model_ci_app_aggregation_function.rs
+++ b/src/datadogV2/model/model_ci_app_aggregation_function.rs
@@ -2,42 +2,26 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CIAppAggregationFunction {
-    #[serde(rename = "count")]
     COUNT,
-    #[serde(rename = "cardinality")]
     CARDINALITY,
-    #[serde(rename = "pc75")]
     PERCENTILE_75,
-    #[serde(rename = "pc90")]
     PERCENTILE_90,
-    #[serde(rename = "pc95")]
     PERCENTILE_95,
-    #[serde(rename = "pc98")]
     PERCENTILE_98,
-    #[serde(rename = "pc99")]
     PERCENTILE_99,
-    #[serde(rename = "sum")]
     SUM,
-    #[serde(rename = "min")]
     MIN,
-    #[serde(rename = "max")]
     MAX,
-    #[serde(rename = "avg")]
     AVG,
-    #[serde(rename = "median")]
     MEDIAN,
-    #[serde(rename = "latest")]
     LATEST,
-    #[serde(rename = "earliest")]
     EARLIEST,
-    #[serde(rename = "most_frequent")]
     MOST_FREQUENT,
-    #[serde(rename = "delta")]
     DELTA,
 }
 
@@ -63,3 +47,47 @@ impl ToString for CIAppAggregationFunction {
         }
     }
 }
+
+impl Serialize for CIAppAggregationFunction {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CIAppAggregationFunction {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "count" => Self::COUNT,
+            "cardinality" => Self::CARDINALITY,
+            "pc75" => Self::PERCENTILE_75,
+            "pc90" => Self::PERCENTILE_90,
+            "pc95" => Self::PERCENTILE_95,
+            "pc98" => Self::PERCENTILE_98,
+            "pc99" => Self::PERCENTILE_99,
+            "sum" => Self::SUM,
+            "min" => Self::MIN,
+            "max" => Self::MAX,
+            "avg" => Self::AVG,
+            "median" => Self::MEDIAN,
+            "latest" => Self::LATEST,
+            "earliest" => Self::EARLIEST,
+            "most_frequent" => Self::MOST_FREQUENT,
+            "delta" => Self::DELTA,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_ci_app_ci_error_domain.rs b/src/datadogV2/model/model_ci_app_ci_error_domain.rs
index 2eb572508..d1401e6a9 100644
--- a/src/datadogV2/model/model_ci_app_ci_error_domain.rs
+++ b/src/datadogV2/model/model_ci_app_ci_error_domain.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CIAppCIErrorDomain {
-    #[serde(rename = "provider")]
     PROVIDER,
-    #[serde(rename = "user")]
     USER,
-    #[serde(rename = "unknown")]
     UNKNOWN,
 }
 
@@ -24,3 +21,34 @@ impl ToString for CIAppCIErrorDomain {
         }
     }
 }
+
+impl Serialize for CIAppCIErrorDomain {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CIAppCIErrorDomain {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "provider" => Self::PROVIDER,
+            "user" => Self::USER,
+            "unknown" => Self::UNKNOWN,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_ci_app_compute_type.rs b/src/datadogV2/model/model_ci_app_compute_type.rs
index 129439c36..9503bd3d9 100644
--- a/src/datadogV2/model/model_ci_app_compute_type.rs
+++ b/src/datadogV2/model/model_ci_app_compute_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CIAppComputeType {
-    #[serde(rename = "timeseries")]
     TIMESERIES,
-    #[serde(rename = "total")]
     TOTAL,
 }
 
@@ -21,3 +19,33 @@ impl ToString for CIAppComputeType {
         }
     }
 }
+
+impl Serialize for CIAppComputeType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CIAppComputeType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "timeseries" => Self::TIMESERIES,
+            "total" => Self::TOTAL,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_ci_app_create_pipeline_event_request_data_type.rs b/src/datadogV2/model/model_ci_app_create_pipeline_event_request_data_type.rs
index fba1bb932..b54a2fe46 100644
--- a/src/datadogV2/model/model_ci_app_create_pipeline_event_request_data_type.rs
+++ b/src/datadogV2/model/model_ci_app_create_pipeline_event_request_data_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CIAppCreatePipelineEventRequestDataType {
-    #[serde(rename = "cipipeline_resource_request")]
     CIPIPELINE_RESOURCE_REQUEST,
 }
 
@@ -18,3 +17,32 @@ impl ToString for CIAppCreatePipelineEventRequestDataType {
         }
     }
 }
+
+impl Serialize for CIAppCreatePipelineEventRequestDataType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CIAppCreatePipelineEventRequestDataType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "cipipeline_resource_request" => Self::CIPIPELINE_RESOURCE_REQUEST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_ci_app_pipeline_event_job_level.rs b/src/datadogV2/model/model_ci_app_pipeline_event_job_level.rs
index 3793a1b84..195727f3c 100644
--- a/src/datadogV2/model/model_ci_app_pipeline_event_job_level.rs
+++ b/src/datadogV2/model/model_ci_app_pipeline_event_job_level.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CIAppPipelineEventJobLevel {
-    #[serde(rename = "job")]
     JOB,
 }
 
@@ -18,3 +17,32 @@ impl ToString for CIAppPipelineEventJobLevel {
         }
     }
 }
+
+impl Serialize for CIAppPipelineEventJobLevel {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CIAppPipelineEventJobLevel {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "job" => Self::JOB,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_ci_app_pipeline_event_job_status.rs b/src/datadogV2/model/model_ci_app_pipeline_event_job_status.rs
index a61183721..305918d22 100644
--- a/src/datadogV2/model/model_ci_app_pipeline_event_job_status.rs
+++ b/src/datadogV2/model/model_ci_app_pipeline_event_job_status.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CIAppPipelineEventJobStatus {
-    #[serde(rename = "success")]
     SUCCESS,
-    #[serde(rename = "error")]
     ERROR,
-    #[serde(rename = "canceled")]
     CANCELED,
-    #[serde(rename = "skipped")]
     SKIPPED,
 }
 
@@ -27,3 +23,35 @@ impl ToString for CIAppPipelineEventJobStatus {
         }
     }
 }
+
+impl Serialize for CIAppPipelineEventJobStatus {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CIAppPipelineEventJobStatus {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "success" => Self::SUCCESS,
+            "error" => Self::ERROR,
+            "canceled" => Self::CANCELED,
+            "skipped" => Self::SKIPPED,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_ci_app_pipeline_event_pipeline_level.rs b/src/datadogV2/model/model_ci_app_pipeline_event_pipeline_level.rs
index 533e89947..424ec3019 100644
--- a/src/datadogV2/model/model_ci_app_pipeline_event_pipeline_level.rs
+++ b/src/datadogV2/model/model_ci_app_pipeline_event_pipeline_level.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CIAppPipelineEventPipelineLevel {
-    #[serde(rename = "pipeline")]
     PIPELINE,
 }
 
@@ -18,3 +17,32 @@ impl ToString for CIAppPipelineEventPipelineLevel {
         }
     }
 }
+
+impl Serialize for CIAppPipelineEventPipelineLevel {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CIAppPipelineEventPipelineLevel {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "pipeline" => Self::PIPELINE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_ci_app_pipeline_event_pipeline_status.rs b/src/datadogV2/model/model_ci_app_pipeline_event_pipeline_status.rs
index 88025f81d..db3cbece9 100644
--- a/src/datadogV2/model/model_ci_app_pipeline_event_pipeline_status.rs
+++ b/src/datadogV2/model/model_ci_app_pipeline_event_pipeline_status.rs
@@ -2,20 +2,15 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CIAppPipelineEventPipelineStatus {
-    #[serde(rename = "success")]
     SUCCESS,
-    #[serde(rename = "error")]
     ERROR,
-    #[serde(rename = "canceled")]
     CANCELED,
-    #[serde(rename = "skipped")]
     SKIPPED,
-    #[serde(rename = "blocked")]
     BLOCKED,
 }
 
@@ -30,3 +25,36 @@ impl ToString for CIAppPipelineEventPipelineStatus {
         }
     }
 }
+
+impl Serialize for CIAppPipelineEventPipelineStatus {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CIAppPipelineEventPipelineStatus {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "success" => Self::SUCCESS,
+            "error" => Self::ERROR,
+            "canceled" => Self::CANCELED,
+            "skipped" => Self::SKIPPED,
+            "blocked" => Self::BLOCKED,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_ci_app_pipeline_event_stage_level.rs b/src/datadogV2/model/model_ci_app_pipeline_event_stage_level.rs
index c03eacc48..c8073fc7b 100644
--- a/src/datadogV2/model/model_ci_app_pipeline_event_stage_level.rs
+++ b/src/datadogV2/model/model_ci_app_pipeline_event_stage_level.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CIAppPipelineEventStageLevel {
-    #[serde(rename = "stage")]
     STAGE,
 }
 
@@ -18,3 +17,32 @@ impl ToString for CIAppPipelineEventStageLevel {
         }
     }
 }
+
+impl Serialize for CIAppPipelineEventStageLevel {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CIAppPipelineEventStageLevel {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "stage" => Self::STAGE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_ci_app_pipeline_event_stage_status.rs b/src/datadogV2/model/model_ci_app_pipeline_event_stage_status.rs
index af1723254..0edb4f70c 100644
--- a/src/datadogV2/model/model_ci_app_pipeline_event_stage_status.rs
+++ b/src/datadogV2/model/model_ci_app_pipeline_event_stage_status.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CIAppPipelineEventStageStatus {
-    #[serde(rename = "success")]
     SUCCESS,
-    #[serde(rename = "error")]
     ERROR,
-    #[serde(rename = "canceled")]
     CANCELED,
-    #[serde(rename = "skipped")]
     SKIPPED,
 }
 
@@ -27,3 +23,35 @@ impl ToString for CIAppPipelineEventStageStatus {
         }
     }
 }
+
+impl Serialize for CIAppPipelineEventStageStatus {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CIAppPipelineEventStageStatus {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "success" => Self::SUCCESS,
+            "error" => Self::ERROR,
+            "canceled" => Self::CANCELED,
+            "skipped" => Self::SKIPPED,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_ci_app_pipeline_event_step_level.rs b/src/datadogV2/model/model_ci_app_pipeline_event_step_level.rs
index efe8d94ae..659a07b46 100644
--- a/src/datadogV2/model/model_ci_app_pipeline_event_step_level.rs
+++ b/src/datadogV2/model/model_ci_app_pipeline_event_step_level.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CIAppPipelineEventStepLevel {
-    #[serde(rename = "step")]
     STEP,
 }
 
@@ -18,3 +17,32 @@ impl ToString for CIAppPipelineEventStepLevel {
         }
     }
 }
+
+impl Serialize for CIAppPipelineEventStepLevel {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CIAppPipelineEventStepLevel {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "step" => Self::STEP,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_ci_app_pipeline_event_step_status.rs b/src/datadogV2/model/model_ci_app_pipeline_event_step_status.rs
index a19b484fc..8d72831ac 100644
--- a/src/datadogV2/model/model_ci_app_pipeline_event_step_status.rs
+++ b/src/datadogV2/model/model_ci_app_pipeline_event_step_status.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CIAppPipelineEventStepStatus {
-    #[serde(rename = "success")]
     SUCCESS,
-    #[serde(rename = "error")]
     ERROR,
 }
 
@@ -21,3 +19,33 @@ impl ToString for CIAppPipelineEventStepStatus {
         }
     }
 }
+
+impl Serialize for CIAppPipelineEventStepStatus {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CIAppPipelineEventStepStatus {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "success" => Self::SUCCESS,
+            "error" => Self::ERROR,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_ci_app_pipeline_event_type_name.rs b/src/datadogV2/model/model_ci_app_pipeline_event_type_name.rs
index 6d3ad0cc8..0a00fbac2 100644
--- a/src/datadogV2/model/model_ci_app_pipeline_event_type_name.rs
+++ b/src/datadogV2/model/model_ci_app_pipeline_event_type_name.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CIAppPipelineEventTypeName {
-    #[serde(rename = "cipipeline")]
     CIPIPELINE,
 }
 
@@ -18,3 +17,32 @@ impl ToString for CIAppPipelineEventTypeName {
         }
     }
 }
+
+impl Serialize for CIAppPipelineEventTypeName {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CIAppPipelineEventTypeName {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "cipipeline" => Self::CIPIPELINE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_ci_app_pipeline_level.rs b/src/datadogV2/model/model_ci_app_pipeline_level.rs
index 199dd8368..8659e4e63 100644
--- a/src/datadogV2/model/model_ci_app_pipeline_level.rs
+++ b/src/datadogV2/model/model_ci_app_pipeline_level.rs
@@ -2,20 +2,15 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CIAppPipelineLevel {
-    #[serde(rename = "pipeline")]
     PIPELINE,
-    #[serde(rename = "stage")]
     STAGE,
-    #[serde(rename = "job")]
     JOB,
-    #[serde(rename = "step")]
     STEP,
-    #[serde(rename = "custom")]
     CUSTOM,
 }
 
@@ -30,3 +25,36 @@ impl ToString for CIAppPipelineLevel {
         }
     }
 }
+
+impl Serialize for CIAppPipelineLevel {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CIAppPipelineLevel {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "pipeline" => Self::PIPELINE,
+            "stage" => Self::STAGE,
+            "job" => Self::JOB,
+            "step" => Self::STEP,
+            "custom" => Self::CUSTOM,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_ci_app_response_status.rs b/src/datadogV2/model/model_ci_app_response_status.rs
index 338b2df5d..88792ce17 100644
--- a/src/datadogV2/model/model_ci_app_response_status.rs
+++ b/src/datadogV2/model/model_ci_app_response_status.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CIAppResponseStatus {
-    #[serde(rename = "done")]
     DONE,
-    #[serde(rename = "timeout")]
     TIMEOUT,
 }
 
@@ -21,3 +19,33 @@ impl ToString for CIAppResponseStatus {
         }
     }
 }
+
+impl Serialize for CIAppResponseStatus {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CIAppResponseStatus {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "done" => Self::DONE,
+            "timeout" => Self::TIMEOUT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_ci_app_sort.rs b/src/datadogV2/model/model_ci_app_sort.rs
index eb6536306..fbbc0aa94 100644
--- a/src/datadogV2/model/model_ci_app_sort.rs
+++ b/src/datadogV2/model/model_ci_app_sort.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CIAppSort {
-    #[serde(rename = "timestamp")]
     TIMESTAMP_ASCENDING,
-    #[serde(rename = "-timestamp")]
     TIMESTAMP_DESCENDING,
 }
 
@@ -21,3 +19,33 @@ impl ToString for CIAppSort {
         }
     }
 }
+
+impl Serialize for CIAppSort {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CIAppSort {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "timestamp" => Self::TIMESTAMP_ASCENDING,
+            "-timestamp" => Self::TIMESTAMP_DESCENDING,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_ci_app_sort_order.rs b/src/datadogV2/model/model_ci_app_sort_order.rs
index a46e0affa..4a486535d 100644
--- a/src/datadogV2/model/model_ci_app_sort_order.rs
+++ b/src/datadogV2/model/model_ci_app_sort_order.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CIAppSortOrder {
-    #[serde(rename = "asc")]
     ASCENDING,
-    #[serde(rename = "desc")]
     DESCENDING,
 }
 
@@ -21,3 +19,33 @@ impl ToString for CIAppSortOrder {
         }
     }
 }
+
+impl Serialize for CIAppSortOrder {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CIAppSortOrder {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "asc" => Self::ASCENDING,
+            "desc" => Self::DESCENDING,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_ci_app_test_event_type_name.rs b/src/datadogV2/model/model_ci_app_test_event_type_name.rs
index 433cffcf2..713f14206 100644
--- a/src/datadogV2/model/model_ci_app_test_event_type_name.rs
+++ b/src/datadogV2/model/model_ci_app_test_event_type_name.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CIAppTestEventTypeName {
-    #[serde(rename = "citest")]
     CITEST,
 }
 
@@ -18,3 +17,32 @@ impl ToString for CIAppTestEventTypeName {
         }
     }
 }
+
+impl Serialize for CIAppTestEventTypeName {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CIAppTestEventTypeName {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "citest" => Self::CITEST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_ci_app_test_level.rs b/src/datadogV2/model/model_ci_app_test_level.rs
index be40a7af2..404bf7e25 100644
--- a/src/datadogV2/model/model_ci_app_test_level.rs
+++ b/src/datadogV2/model/model_ci_app_test_level.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CIAppTestLevel {
-    #[serde(rename = "session")]
     SESSION,
-    #[serde(rename = "module")]
     MODULE,
-    #[serde(rename = "suite")]
     SUITE,
-    #[serde(rename = "test")]
     TEST,
 }
 
@@ -27,3 +23,35 @@ impl ToString for CIAppTestLevel {
         }
     }
 }
+
+impl Serialize for CIAppTestLevel {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CIAppTestLevel {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "session" => Self::SESSION,
+            "module" => Self::MODULE,
+            "suite" => Self::SUITE,
+            "test" => Self::TEST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_cloud_configuration_rule_type.rs b/src/datadogV2/model/model_cloud_configuration_rule_type.rs
index 9d88e3b50..51d373645 100644
--- a/src/datadogV2/model/model_cloud_configuration_rule_type.rs
+++ b/src/datadogV2/model/model_cloud_configuration_rule_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CloudConfigurationRuleType {
-    #[serde(rename = "cloud_configuration")]
     CLOUD_CONFIGURATION,
 }
 
@@ -18,3 +17,32 @@ impl ToString for CloudConfigurationRuleType {
         }
     }
 }
+
+impl Serialize for CloudConfigurationRuleType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CloudConfigurationRuleType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "cloud_configuration" => Self::CLOUD_CONFIGURATION,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_cloud_cost_activity_type.rs b/src/datadogV2/model/model_cloud_cost_activity_type.rs
index 1801aa8bc..cb1c96780 100644
--- a/src/datadogV2/model/model_cloud_cost_activity_type.rs
+++ b/src/datadogV2/model/model_cloud_cost_activity_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CloudCostActivityType {
-    #[serde(rename = "cloud_cost_activity")]
     CLOUD_COST_ACTIVITY,
 }
 
@@ -18,3 +17,32 @@ impl ToString for CloudCostActivityType {
         }
     }
 }
+
+impl Serialize for CloudCostActivityType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CloudCostActivityType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "cloud_cost_activity" => Self::CLOUD_COST_ACTIVITY,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_cloud_workload_security_agent_rule_type.rs b/src/datadogV2/model/model_cloud_workload_security_agent_rule_type.rs
index 70b5cd3e3..f9b5ea201 100644
--- a/src/datadogV2/model/model_cloud_workload_security_agent_rule_type.rs
+++ b/src/datadogV2/model/model_cloud_workload_security_agent_rule_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CloudWorkloadSecurityAgentRuleType {
-    #[serde(rename = "agent_rule")]
     AGENT_RULE,
 }
 
@@ -18,3 +17,32 @@ impl ToString for CloudWorkloadSecurityAgentRuleType {
         }
     }
 }
+
+impl Serialize for CloudWorkloadSecurityAgentRuleType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CloudWorkloadSecurityAgentRuleType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "agent_rule" => Self::AGENT_RULE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_cloudflare_account_type.rs b/src/datadogV2/model/model_cloudflare_account_type.rs
index bd87199b3..211d73903 100644
--- a/src/datadogV2/model/model_cloudflare_account_type.rs
+++ b/src/datadogV2/model/model_cloudflare_account_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CloudflareAccountType {
-    #[serde(rename = "cloudflare-accounts")]
     CLOUDFLARE_ACCOUNTS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for CloudflareAccountType {
         }
     }
 }
+
+impl Serialize for CloudflareAccountType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CloudflareAccountType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "cloudflare-accounts" => Self::CLOUDFLARE_ACCOUNTS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_confluent_account_type.rs b/src/datadogV2/model/model_confluent_account_type.rs
index 7fbd0d6e5..c3c0d0c8f 100644
--- a/src/datadogV2/model/model_confluent_account_type.rs
+++ b/src/datadogV2/model/model_confluent_account_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ConfluentAccountType {
-    #[serde(rename = "confluent-cloud-accounts")]
     CONFLUENT_CLOUD_ACCOUNTS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ConfluentAccountType {
         }
     }
 }
+
+impl Serialize for ConfluentAccountType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ConfluentAccountType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "confluent-cloud-accounts" => Self::CONFLUENT_CLOUD_ACCOUNTS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_confluent_resource_type.rs b/src/datadogV2/model/model_confluent_resource_type.rs
index 70465a521..ddead9208 100644
--- a/src/datadogV2/model/model_confluent_resource_type.rs
+++ b/src/datadogV2/model/model_confluent_resource_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ConfluentResourceType {
-    #[serde(rename = "confluent-cloud-resources")]
     CONFLUENT_CLOUD_RESOURCES,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ConfluentResourceType {
         }
     }
 }
+
+impl Serialize for ConfluentResourceType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ConfluentResourceType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "confluent-cloud-resources" => Self::CONFLUENT_CLOUD_RESOURCES,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_container_group_type.rs b/src/datadogV2/model/model_container_group_type.rs
index 8d8a66c9a..da39b4257 100644
--- a/src/datadogV2/model/model_container_group_type.rs
+++ b/src/datadogV2/model/model_container_group_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ContainerGroupType {
-    #[serde(rename = "container_group")]
     CONTAINER_GROUP,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ContainerGroupType {
         }
     }
 }
+
+impl Serialize for ContainerGroupType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ContainerGroupType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "container_group" => Self::CONTAINER_GROUP,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_container_image_group_type.rs b/src/datadogV2/model/model_container_image_group_type.rs
index f4898446a..49166d687 100644
--- a/src/datadogV2/model/model_container_image_group_type.rs
+++ b/src/datadogV2/model/model_container_image_group_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ContainerImageGroupType {
-    #[serde(rename = "container_image_group")]
     CONTAINER_IMAGE_GROUP,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ContainerImageGroupType {
         }
     }
 }
+
+impl Serialize for ContainerImageGroupType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ContainerImageGroupType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "container_image_group" => Self::CONTAINER_IMAGE_GROUP,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_container_image_meta_page_type.rs b/src/datadogV2/model/model_container_image_meta_page_type.rs
index ab45c771d..51d2f1df2 100644
--- a/src/datadogV2/model/model_container_image_meta_page_type.rs
+++ b/src/datadogV2/model/model_container_image_meta_page_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ContainerImageMetaPageType {
-    #[serde(rename = "cursor_limit")]
     CURSOR_LIMIT,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ContainerImageMetaPageType {
         }
     }
 }
+
+impl Serialize for ContainerImageMetaPageType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ContainerImageMetaPageType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "cursor_limit" => Self::CURSOR_LIMIT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_container_image_type.rs b/src/datadogV2/model/model_container_image_type.rs
index 9c7a1719e..7fb9e3519 100644
--- a/src/datadogV2/model/model_container_image_type.rs
+++ b/src/datadogV2/model/model_container_image_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ContainerImageType {
-    #[serde(rename = "container_image")]
     CONTAINER_IMAGE,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ContainerImageType {
         }
     }
 }
+
+impl Serialize for ContainerImageType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ContainerImageType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "container_image" => Self::CONTAINER_IMAGE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_container_meta_page_type.rs b/src/datadogV2/model/model_container_meta_page_type.rs
index c92d1433a..1bdd995be 100644
--- a/src/datadogV2/model/model_container_meta_page_type.rs
+++ b/src/datadogV2/model/model_container_meta_page_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ContainerMetaPageType {
-    #[serde(rename = "cursor_limit")]
     CURSOR_LIMIT,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ContainerMetaPageType {
         }
     }
 }
+
+impl Serialize for ContainerMetaPageType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ContainerMetaPageType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "cursor_limit" => Self::CURSOR_LIMIT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_container_type.rs b/src/datadogV2/model/model_container_type.rs
index 84564b7e3..f4d92f5c1 100644
--- a/src/datadogV2/model/model_container_type.rs
+++ b/src/datadogV2/model/model_container_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ContainerType {
-    #[serde(rename = "container")]
     CONTAINER,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ContainerType {
         }
     }
 }
+
+impl Serialize for ContainerType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ContainerType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "container" => Self::CONTAINER,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_content_encoding.rs b/src/datadogV2/model/model_content_encoding.rs
index a296c8c1f..a859cc201 100644
--- a/src/datadogV2/model/model_content_encoding.rs
+++ b/src/datadogV2/model/model_content_encoding.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ContentEncoding {
-    #[serde(rename = "identity")]
     IDENTITY,
-    #[serde(rename = "gzip")]
     GZIP,
-    #[serde(rename = "deflate")]
     DEFLATE,
 }
 
@@ -24,3 +21,34 @@ impl ToString for ContentEncoding {
         }
     }
 }
+
+impl Serialize for ContentEncoding {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ContentEncoding {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "identity" => Self::IDENTITY,
+            "gzip" => Self::GZIP,
+            "deflate" => Self::DEFLATE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_cost_attribution_type.rs b/src/datadogV2/model/model_cost_attribution_type.rs
index b9a182e97..498a6c6a3 100644
--- a/src/datadogV2/model/model_cost_attribution_type.rs
+++ b/src/datadogV2/model/model_cost_attribution_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CostAttributionType {
-    #[serde(rename = "cost_by_tag")]
     COST_BY_TAG,
 }
 
@@ -18,3 +17,32 @@ impl ToString for CostAttributionType {
         }
     }
 }
+
+impl Serialize for CostAttributionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CostAttributionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "cost_by_tag" => Self::COST_BY_TAG,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_cost_by_org_type.rs b/src/datadogV2/model/model_cost_by_org_type.rs
index 16de593bb..fedc803e2 100644
--- a/src/datadogV2/model/model_cost_by_org_type.rs
+++ b/src/datadogV2/model/model_cost_by_org_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum CostByOrgType {
-    #[serde(rename = "cost_by_org")]
     COST_BY_ORG,
 }
 
@@ -18,3 +17,32 @@ impl ToString for CostByOrgType {
         }
     }
 }
+
+impl Serialize for CostByOrgType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CostByOrgType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "cost_by_org" => Self::COST_BY_ORG,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_dashboard_type.rs b/src/datadogV2/model/model_dashboard_type.rs
index 942d64ba2..91757f20d 100644
--- a/src/datadogV2/model/model_dashboard_type.rs
+++ b/src/datadogV2/model/model_dashboard_type.rs
@@ -2,20 +2,15 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum DashboardType {
-    #[serde(rename = "custom_timeboard")]
     CUSTOM_TIMEBOARD,
-    #[serde(rename = "custom_screenboard")]
     CUSTOM_SCREENBOARD,
-    #[serde(rename = "integration_screenboard")]
     INTEGRATION_SCREENBOARD,
-    #[serde(rename = "integration_timeboard")]
     INTEGRATION_TIMEBOARD,
-    #[serde(rename = "host_timeboard")]
     HOST_TIMEBOARD,
 }
 
@@ -30,3 +25,36 @@ impl ToString for DashboardType {
         }
     }
 }
+
+impl Serialize for DashboardType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for DashboardType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "custom_timeboard" => Self::CUSTOM_TIMEBOARD,
+            "custom_screenboard" => Self::CUSTOM_SCREENBOARD,
+            "integration_screenboard" => Self::INTEGRATION_SCREENBOARD,
+            "integration_timeboard" => Self::INTEGRATION_TIMEBOARD,
+            "host_timeboard" => Self::HOST_TIMEBOARD,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_detailed_finding_type.rs b/src/datadogV2/model/model_detailed_finding_type.rs
index bd6f9a798..802bf22b2 100644
--- a/src/datadogV2/model/model_detailed_finding_type.rs
+++ b/src/datadogV2/model/model_detailed_finding_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum DetailedFindingType {
-    #[serde(rename = "detailed_finding")]
     DETAILED_FINDING,
 }
 
@@ -18,3 +17,32 @@ impl ToString for DetailedFindingType {
         }
     }
 }
+
+impl Serialize for DetailedFindingType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for DetailedFindingType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "detailed_finding" => Self::DETAILED_FINDING,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_dora_deployment_type.rs b/src/datadogV2/model/model_dora_deployment_type.rs
index 3694a60fc..b3f75bc7a 100644
--- a/src/datadogV2/model/model_dora_deployment_type.rs
+++ b/src/datadogV2/model/model_dora_deployment_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum DORADeploymentType {
-    #[serde(rename = "dora_deployment")]
     DORA_DEPLOYMENT,
 }
 
@@ -18,3 +17,32 @@ impl ToString for DORADeploymentType {
         }
     }
 }
+
+impl Serialize for DORADeploymentType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for DORADeploymentType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "dora_deployment" => Self::DORA_DEPLOYMENT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_dora_incident_type.rs b/src/datadogV2/model/model_dora_incident_type.rs
index 347a9a27c..18bfb6081 100644
--- a/src/datadogV2/model/model_dora_incident_type.rs
+++ b/src/datadogV2/model/model_dora_incident_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum DORAIncidentType {
-    #[serde(rename = "dora_incident")]
     DORA_INCIDENT,
 }
 
@@ -18,3 +17,32 @@ impl ToString for DORAIncidentType {
         }
     }
 }
+
+impl Serialize for DORAIncidentType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for DORAIncidentType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "dora_incident" => Self::DORA_INCIDENT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_downtime_included_monitor_type.rs b/src/datadogV2/model/model_downtime_included_monitor_type.rs
index 21c0bc6ae..34b0fe3c5 100644
--- a/src/datadogV2/model/model_downtime_included_monitor_type.rs
+++ b/src/datadogV2/model/model_downtime_included_monitor_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum DowntimeIncludedMonitorType {
-    #[serde(rename = "monitors")]
     MONITORS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for DowntimeIncludedMonitorType {
         }
     }
 }
+
+impl Serialize for DowntimeIncludedMonitorType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for DowntimeIncludedMonitorType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "monitors" => Self::MONITORS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_downtime_notify_end_state_actions.rs b/src/datadogV2/model/model_downtime_notify_end_state_actions.rs
index 5c72c4898..2da1dfc1b 100644
--- a/src/datadogV2/model/model_downtime_notify_end_state_actions.rs
+++ b/src/datadogV2/model/model_downtime_notify_end_state_actions.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum DowntimeNotifyEndStateActions {
-    #[serde(rename = "canceled")]
     CANCELED,
-    #[serde(rename = "expired")]
     EXPIRED,
 }
 
@@ -21,3 +19,33 @@ impl ToString for DowntimeNotifyEndStateActions {
         }
     }
 }
+
+impl Serialize for DowntimeNotifyEndStateActions {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for DowntimeNotifyEndStateActions {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "canceled" => Self::CANCELED,
+            "expired" => Self::EXPIRED,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_downtime_notify_end_state_types.rs b/src/datadogV2/model/model_downtime_notify_end_state_types.rs
index 0d1e2d2f3..cc7cea6f7 100644
--- a/src/datadogV2/model/model_downtime_notify_end_state_types.rs
+++ b/src/datadogV2/model/model_downtime_notify_end_state_types.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum DowntimeNotifyEndStateTypes {
-    #[serde(rename = "alert")]
     ALERT,
-    #[serde(rename = "no data")]
     NO_DATA,
-    #[serde(rename = "warn")]
     WARN,
 }
 
@@ -24,3 +21,34 @@ impl ToString for DowntimeNotifyEndStateTypes {
         }
     }
 }
+
+impl Serialize for DowntimeNotifyEndStateTypes {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for DowntimeNotifyEndStateTypes {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "alert" => Self::ALERT,
+            "no data" => Self::NO_DATA,
+            "warn" => Self::WARN,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_downtime_resource_type.rs b/src/datadogV2/model/model_downtime_resource_type.rs
index 70d8c9bf6..08cfc2426 100644
--- a/src/datadogV2/model/model_downtime_resource_type.rs
+++ b/src/datadogV2/model/model_downtime_resource_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum DowntimeResourceType {
-    #[serde(rename = "downtime")]
     DOWNTIME,
 }
 
@@ -18,3 +17,32 @@ impl ToString for DowntimeResourceType {
         }
     }
 }
+
+impl Serialize for DowntimeResourceType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for DowntimeResourceType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "downtime" => Self::DOWNTIME,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_downtime_status.rs b/src/datadogV2/model/model_downtime_status.rs
index 4cdfb1bf7..e31ebc535 100644
--- a/src/datadogV2/model/model_downtime_status.rs
+++ b/src/datadogV2/model/model_downtime_status.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum DowntimeStatus {
-    #[serde(rename = "active")]
     ACTIVE,
-    #[serde(rename = "canceled")]
     CANCELED,
-    #[serde(rename = "ended")]
     ENDED,
-    #[serde(rename = "scheduled")]
     SCHEDULED,
 }
 
@@ -27,3 +23,35 @@ impl ToString for DowntimeStatus {
         }
     }
 }
+
+impl Serialize for DowntimeStatus {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for DowntimeStatus {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "active" => Self::ACTIVE,
+            "canceled" => Self::CANCELED,
+            "ended" => Self::ENDED,
+            "scheduled" => Self::SCHEDULED,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_event_priority.rs b/src/datadogV2/model/model_event_priority.rs
index 30943219f..8d009c5b8 100644
--- a/src/datadogV2/model/model_event_priority.rs
+++ b/src/datadogV2/model/model_event_priority.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum EventPriority {
-    #[serde(rename = "normal")]
     NORMAL,
-    #[serde(rename = "low")]
     LOW,
 }
 
@@ -21,3 +19,33 @@ impl ToString for EventPriority {
         }
     }
 }
+
+impl Serialize for EventPriority {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for EventPriority {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "normal" => Self::NORMAL,
+            "low" => Self::LOW,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_event_status_type.rs b/src/datadogV2/model/model_event_status_type.rs
index 41f426a54..c2eb9b848 100644
--- a/src/datadogV2/model/model_event_status_type.rs
+++ b/src/datadogV2/model/model_event_status_type.rs
@@ -2,26 +2,18 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum EventStatusType {
-    #[serde(rename = "failure")]
     FAILURE,
-    #[serde(rename = "error")]
     ERROR,
-    #[serde(rename = "warning")]
     WARNING,
-    #[serde(rename = "info")]
     INFO,
-    #[serde(rename = "success")]
     SUCCESS,
-    #[serde(rename = "user_update")]
     USER_UPDATE,
-    #[serde(rename = "recommendation")]
     RECOMMENDATION,
-    #[serde(rename = "snapshot")]
     SNAPSHOT,
 }
 
@@ -39,3 +31,39 @@ impl ToString for EventStatusType {
         }
     }
 }
+
+impl Serialize for EventStatusType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for EventStatusType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "failure" => Self::FAILURE,
+            "error" => Self::ERROR,
+            "warning" => Self::WARNING,
+            "info" => Self::INFO,
+            "success" => Self::SUCCESS,
+            "user_update" => Self::USER_UPDATE,
+            "recommendation" => Self::RECOMMENDATION,
+            "snapshot" => Self::SNAPSHOT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_event_type.rs b/src/datadogV2/model/model_event_type.rs
index 6fb45a16c..7f053df92 100644
--- a/src/datadogV2/model/model_event_type.rs
+++ b/src/datadogV2/model/model_event_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum EventType {
-    #[serde(rename = "event")]
     EVENT,
 }
 
@@ -18,3 +17,32 @@ impl ToString for EventType {
         }
     }
 }
+
+impl Serialize for EventType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for EventType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "event" => Self::EVENT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_events_aggregation.rs b/src/datadogV2/model/model_events_aggregation.rs
index a0ae72484..fee90ff9f 100644
--- a/src/datadogV2/model/model_events_aggregation.rs
+++ b/src/datadogV2/model/model_events_aggregation.rs
@@ -2,32 +2,21 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum EventsAggregation {
-    #[serde(rename = "count")]
     COUNT,
-    #[serde(rename = "cardinality")]
     CARDINALITY,
-    #[serde(rename = "pc75")]
     PC75,
-    #[serde(rename = "pc90")]
     PC90,
-    #[serde(rename = "pc95")]
     PC95,
-    #[serde(rename = "pc98")]
     PC98,
-    #[serde(rename = "pc99")]
     PC99,
-    #[serde(rename = "sum")]
     SUM,
-    #[serde(rename = "min")]
     MIN,
-    #[serde(rename = "max")]
     MAX,
-    #[serde(rename = "avg")]
     AVG,
 }
 
@@ -48,3 +37,42 @@ impl ToString for EventsAggregation {
         }
     }
 }
+
+impl Serialize for EventsAggregation {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for EventsAggregation {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "count" => Self::COUNT,
+            "cardinality" => Self::CARDINALITY,
+            "pc75" => Self::PC75,
+            "pc90" => Self::PC90,
+            "pc95" => Self::PC95,
+            "pc98" => Self::PC98,
+            "pc99" => Self::PC99,
+            "sum" => Self::SUM,
+            "min" => Self::MIN,
+            "max" => Self::MAX,
+            "avg" => Self::AVG,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_events_data_source.rs b/src/datadogV2/model/model_events_data_source.rs
index 6c02212a7..8d8ba6d43 100644
--- a/src/datadogV2/model/model_events_data_source.rs
+++ b/src/datadogV2/model/model_events_data_source.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum EventsDataSource {
-    #[serde(rename = "logs")]
     LOGS,
-    #[serde(rename = "rum")]
     RUM,
 }
 
@@ -21,3 +19,33 @@ impl ToString for EventsDataSource {
         }
     }
 }
+
+impl Serialize for EventsDataSource {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for EventsDataSource {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "logs" => Self::LOGS,
+            "rum" => Self::RUM,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_events_sort.rs b/src/datadogV2/model/model_events_sort.rs
index a936a4f58..d8206e516 100644
--- a/src/datadogV2/model/model_events_sort.rs
+++ b/src/datadogV2/model/model_events_sort.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum EventsSort {
-    #[serde(rename = "timestamp")]
     TIMESTAMP_ASCENDING,
-    #[serde(rename = "-timestamp")]
     TIMESTAMP_DESCENDING,
 }
 
@@ -21,3 +19,33 @@ impl ToString for EventsSort {
         }
     }
 }
+
+impl Serialize for EventsSort {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for EventsSort {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "timestamp" => Self::TIMESTAMP_ASCENDING,
+            "-timestamp" => Self::TIMESTAMP_DESCENDING,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_events_sort_type.rs b/src/datadogV2/model/model_events_sort_type.rs
index 6e4792827..eb74fe5ab 100644
--- a/src/datadogV2/model/model_events_sort_type.rs
+++ b/src/datadogV2/model/model_events_sort_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum EventsSortType {
-    #[serde(rename = "alphabetical")]
     ALPHABETICAL,
-    #[serde(rename = "measure")]
     MEASURE,
 }
 
@@ -21,3 +19,33 @@ impl ToString for EventsSortType {
         }
     }
 }
+
+impl Serialize for EventsSortType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for EventsSortType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "alphabetical" => Self::ALPHABETICAL,
+            "measure" => Self::MEASURE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_fastly_account_type.rs b/src/datadogV2/model/model_fastly_account_type.rs
index c708bd1f8..41f001679 100644
--- a/src/datadogV2/model/model_fastly_account_type.rs
+++ b/src/datadogV2/model/model_fastly_account_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FastlyAccountType {
-    #[serde(rename = "fastly-accounts")]
     FASTLY_ACCOUNTS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for FastlyAccountType {
         }
     }
 }
+
+impl Serialize for FastlyAccountType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FastlyAccountType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "fastly-accounts" => Self::FASTLY_ACCOUNTS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_fastly_service_type.rs b/src/datadogV2/model/model_fastly_service_type.rs
index f0567bcbe..073df92ed 100644
--- a/src/datadogV2/model/model_fastly_service_type.rs
+++ b/src/datadogV2/model/model_fastly_service_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FastlyServiceType {
-    #[serde(rename = "fastly-services")]
     FASTLY_SERVICES,
 }
 
@@ -18,3 +17,32 @@ impl ToString for FastlyServiceType {
         }
     }
 }
+
+impl Serialize for FastlyServiceType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FastlyServiceType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "fastly-services" => Self::FASTLY_SERVICES,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_finding_evaluation.rs b/src/datadogV2/model/model_finding_evaluation.rs
index b6f5a8e5c..3856012bf 100644
--- a/src/datadogV2/model/model_finding_evaluation.rs
+++ b/src/datadogV2/model/model_finding_evaluation.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FindingEvaluation {
-    #[serde(rename = "pass")]
     PASS,
-    #[serde(rename = "fail")]
     FAIL,
 }
 
@@ -21,3 +19,33 @@ impl ToString for FindingEvaluation {
         }
     }
 }
+
+impl Serialize for FindingEvaluation {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FindingEvaluation {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "pass" => Self::PASS,
+            "fail" => Self::FAIL,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_finding_mute_reason.rs b/src/datadogV2/model/model_finding_mute_reason.rs
index 515b41282..e417d61d3 100644
--- a/src/datadogV2/model/model_finding_mute_reason.rs
+++ b/src/datadogV2/model/model_finding_mute_reason.rs
@@ -2,24 +2,17 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FindingMuteReason {
-    #[serde(rename = "PENDING_FIX")]
     PENDING_FIX,
-    #[serde(rename = "FALSE_POSITIVE")]
     FALSE_POSITIVE,
-    #[serde(rename = "ACCEPTED_RISK")]
     ACCEPTED_RISK,
-    #[serde(rename = "NO_PENDING_FIX")]
     NO_PENDING_FIX,
-    #[serde(rename = "HUMAN_ERROR")]
     HUMAN_ERROR,
-    #[serde(rename = "NO_LONGER_ACCEPTED_RISK")]
     NO_LONGER_ACCEPTED_RISK,
-    #[serde(rename = "OTHER")]
     OTHER,
 }
 
@@ -36,3 +29,38 @@ impl ToString for FindingMuteReason {
         }
     }
 }
+
+impl Serialize for FindingMuteReason {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FindingMuteReason {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "PENDING_FIX" => Self::PENDING_FIX,
+            "FALSE_POSITIVE" => Self::FALSE_POSITIVE,
+            "ACCEPTED_RISK" => Self::ACCEPTED_RISK,
+            "NO_PENDING_FIX" => Self::NO_PENDING_FIX,
+            "HUMAN_ERROR" => Self::HUMAN_ERROR,
+            "NO_LONGER_ACCEPTED_RISK" => Self::NO_LONGER_ACCEPTED_RISK,
+            "OTHER" => Self::OTHER,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_finding_status.rs b/src/datadogV2/model/model_finding_status.rs
index 9bbf56594..0bfeacaa6 100644
--- a/src/datadogV2/model/model_finding_status.rs
+++ b/src/datadogV2/model/model_finding_status.rs
@@ -2,20 +2,15 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FindingStatus {
-    #[serde(rename = "critical")]
     CRITICAL,
-    #[serde(rename = "high")]
     HIGH,
-    #[serde(rename = "medium")]
     MEDIUM,
-    #[serde(rename = "low")]
     LOW,
-    #[serde(rename = "info")]
     INFO,
 }
 
@@ -30,3 +25,36 @@ impl ToString for FindingStatus {
         }
     }
 }
+
+impl Serialize for FindingStatus {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FindingStatus {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "critical" => Self::CRITICAL,
+            "high" => Self::HIGH,
+            "medium" => Self::MEDIUM,
+            "low" => Self::LOW,
+            "info" => Self::INFO,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_finding_type.rs b/src/datadogV2/model/model_finding_type.rs
index 732d8facb..3bdabc947 100644
--- a/src/datadogV2/model/model_finding_type.rs
+++ b/src/datadogV2/model/model_finding_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FindingType {
-    #[serde(rename = "finding")]
     FINDING,
 }
 
@@ -18,3 +17,32 @@ impl ToString for FindingType {
         }
     }
 }
+
+impl Serialize for FindingType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FindingType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "finding" => Self::FINDING,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_gcp_service_account_type.rs b/src/datadogV2/model/model_gcp_service_account_type.rs
index 45c4c390e..def5c6867 100644
--- a/src/datadogV2/model/model_gcp_service_account_type.rs
+++ b/src/datadogV2/model/model_gcp_service_account_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum GCPServiceAccountType {
-    #[serde(rename = "gcp_service_account")]
     GCP_SERVICE_ACCOUNT,
 }
 
@@ -18,3 +17,32 @@ impl ToString for GCPServiceAccountType {
         }
     }
 }
+
+impl Serialize for GCPServiceAccountType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for GCPServiceAccountType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "gcp_service_account" => Self::GCP_SERVICE_ACCOUNT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_gcpsts_delegate_account_type.rs b/src/datadogV2/model/model_gcpsts_delegate_account_type.rs
index a57918f5b..08cec6cf9 100644
--- a/src/datadogV2/model/model_gcpsts_delegate_account_type.rs
+++ b/src/datadogV2/model/model_gcpsts_delegate_account_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum GCPSTSDelegateAccountType {
-    #[serde(rename = "gcp_sts_delegate")]
     GCP_STS_DELEGATE,
 }
 
@@ -18,3 +17,32 @@ impl ToString for GCPSTSDelegateAccountType {
         }
     }
 }
+
+impl Serialize for GCPSTSDelegateAccountType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for GCPSTSDelegateAccountType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "gcp_sts_delegate" => Self::GCP_STS_DELEGATE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_get_team_memberships_sort.rs b/src/datadogV2/model/model_get_team_memberships_sort.rs
index 7fa61d26f..5872c6c08 100644
--- a/src/datadogV2/model/model_get_team_memberships_sort.rs
+++ b/src/datadogV2/model/model_get_team_memberships_sort.rs
@@ -2,26 +2,18 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum GetTeamMembershipsSort {
-    #[serde(rename = "manager_name")]
     MANAGER_NAME,
-    #[serde(rename = "-manager_name")]
     _MANAGER_NAME,
-    #[serde(rename = "name")]
     NAME,
-    #[serde(rename = "-name")]
     _NAME,
-    #[serde(rename = "handle")]
     HANDLE,
-    #[serde(rename = "-handle")]
     _HANDLE,
-    #[serde(rename = "email")]
     EMAIL,
-    #[serde(rename = "-email")]
     _EMAIL,
 }
 
@@ -39,3 +31,39 @@ impl ToString for GetTeamMembershipsSort {
         }
     }
 }
+
+impl Serialize for GetTeamMembershipsSort {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for GetTeamMembershipsSort {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "manager_name" => Self::MANAGER_NAME,
+            "-manager_name" => Self::_MANAGER_NAME,
+            "name" => Self::NAME,
+            "-name" => Self::_NAME,
+            "handle" => Self::HANDLE,
+            "-handle" => Self::_HANDLE,
+            "email" => Self::EMAIL,
+            "-email" => Self::_EMAIL,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_hourly_usage_type.rs b/src/datadogV2/model/model_hourly_usage_type.rs
index 44d6acd1e..5ff3b829b 100644
--- a/src/datadogV2/model/model_hourly_usage_type.rs
+++ b/src/datadogV2/model/model_hourly_usage_type.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum HourlyUsageType {
-    #[serde(rename = "app_sec_host_count")]
     APP_SEC_HOST_COUNT,
-    #[serde(rename = "observability_pipelines_bytes_processed")]
     OBSERVABILITY_PIPELINES_BYTES_PROCESSSED,
-    #[serde(rename = "lambda_traced_invocations_count")]
     LAMBDA_TRACED_INVOCATIONS_COUNT,
 }
 
@@ -28,3 +25,36 @@ impl ToString for HourlyUsageType {
         }
     }
 }
+
+impl Serialize for HourlyUsageType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for HourlyUsageType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "app_sec_host_count" => Self::APP_SEC_HOST_COUNT,
+            "observability_pipelines_bytes_processed" => {
+                Self::OBSERVABILITY_PIPELINES_BYTES_PROCESSSED
+            }
+            "lambda_traced_invocations_count" => Self::LAMBDA_TRACED_INVOCATIONS_COUNT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_incident_attachment_attachment_type.rs b/src/datadogV2/model/model_incident_attachment_attachment_type.rs
index b9fb1edad..ac170403e 100644
--- a/src/datadogV2/model/model_incident_attachment_attachment_type.rs
+++ b/src/datadogV2/model/model_incident_attachment_attachment_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IncidentAttachmentAttachmentType {
-    #[serde(rename = "link")]
     LINK,
-    #[serde(rename = "postmortem")]
     POSTMORTEM,
 }
 
@@ -21,3 +19,33 @@ impl ToString for IncidentAttachmentAttachmentType {
         }
     }
 }
+
+impl Serialize for IncidentAttachmentAttachmentType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IncidentAttachmentAttachmentType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "link" => Self::LINK,
+            "postmortem" => Self::POSTMORTEM,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_incident_attachment_link_attachment_type.rs b/src/datadogV2/model/model_incident_attachment_link_attachment_type.rs
index 08b7f0641..a00cf92b6 100644
--- a/src/datadogV2/model/model_incident_attachment_link_attachment_type.rs
+++ b/src/datadogV2/model/model_incident_attachment_link_attachment_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IncidentAttachmentLinkAttachmentType {
-    #[serde(rename = "link")]
     LINK,
 }
 
@@ -18,3 +17,32 @@ impl ToString for IncidentAttachmentLinkAttachmentType {
         }
     }
 }
+
+impl Serialize for IncidentAttachmentLinkAttachmentType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IncidentAttachmentLinkAttachmentType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "link" => Self::LINK,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_incident_attachment_postmortem_attachment_type.rs b/src/datadogV2/model/model_incident_attachment_postmortem_attachment_type.rs
index 701ae52a7..634ac86eb 100644
--- a/src/datadogV2/model/model_incident_attachment_postmortem_attachment_type.rs
+++ b/src/datadogV2/model/model_incident_attachment_postmortem_attachment_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IncidentAttachmentPostmortemAttachmentType {
-    #[serde(rename = "postmortem")]
     POSTMORTEM,
 }
 
@@ -18,3 +17,32 @@ impl ToString for IncidentAttachmentPostmortemAttachmentType {
         }
     }
 }
+
+impl Serialize for IncidentAttachmentPostmortemAttachmentType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IncidentAttachmentPostmortemAttachmentType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "postmortem" => Self::POSTMORTEM,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_incident_attachment_related_object.rs b/src/datadogV2/model/model_incident_attachment_related_object.rs
index 19af6936e..cbc021a04 100644
--- a/src/datadogV2/model/model_incident_attachment_related_object.rs
+++ b/src/datadogV2/model/model_incident_attachment_related_object.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IncidentAttachmentRelatedObject {
-    #[serde(rename = "users")]
     USERS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for IncidentAttachmentRelatedObject {
         }
     }
 }
+
+impl Serialize for IncidentAttachmentRelatedObject {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IncidentAttachmentRelatedObject {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "users" => Self::USERS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_incident_attachment_type.rs b/src/datadogV2/model/model_incident_attachment_type.rs
index 1d8cdd94a..b7d751870 100644
--- a/src/datadogV2/model/model_incident_attachment_type.rs
+++ b/src/datadogV2/model/model_incident_attachment_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IncidentAttachmentType {
-    #[serde(rename = "incident_attachments")]
     INCIDENT_ATTACHMENTS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for IncidentAttachmentType {
         }
     }
 }
+
+impl Serialize for IncidentAttachmentType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IncidentAttachmentType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "incident_attachments" => Self::INCIDENT_ATTACHMENTS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_incident_field_attributes_single_value_type.rs b/src/datadogV2/model/model_incident_field_attributes_single_value_type.rs
index b41116613..253bd2b60 100644
--- a/src/datadogV2/model/model_incident_field_attributes_single_value_type.rs
+++ b/src/datadogV2/model/model_incident_field_attributes_single_value_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IncidentFieldAttributesSingleValueType {
-    #[serde(rename = "dropdown")]
     DROPDOWN,
-    #[serde(rename = "textbox")]
     TEXTBOX,
 }
 
@@ -21,3 +19,33 @@ impl ToString for IncidentFieldAttributesSingleValueType {
         }
     }
 }
+
+impl Serialize for IncidentFieldAttributesSingleValueType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IncidentFieldAttributesSingleValueType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "dropdown" => Self::DROPDOWN,
+            "textbox" => Self::TEXTBOX,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_incident_field_attributes_value_type.rs b/src/datadogV2/model/model_incident_field_attributes_value_type.rs
index 39786f5c4..6b6ad23bc 100644
--- a/src/datadogV2/model/model_incident_field_attributes_value_type.rs
+++ b/src/datadogV2/model/model_incident_field_attributes_value_type.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IncidentFieldAttributesValueType {
-    #[serde(rename = "multiselect")]
     MULTISELECT,
-    #[serde(rename = "textarray")]
     TEXTARRAY,
-    #[serde(rename = "metrictag")]
     METRICTAG,
-    #[serde(rename = "autocomplete")]
     AUTOCOMPLETE,
 }
 
@@ -27,3 +23,35 @@ impl ToString for IncidentFieldAttributesValueType {
         }
     }
 }
+
+impl Serialize for IncidentFieldAttributesValueType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IncidentFieldAttributesValueType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "multiselect" => Self::MULTISELECT,
+            "textarray" => Self::TEXTARRAY,
+            "metrictag" => Self::METRICTAG,
+            "autocomplete" => Self::AUTOCOMPLETE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_incident_impacts_type.rs b/src/datadogV2/model/model_incident_impacts_type.rs
index a04cb0731..66944a04f 100644
--- a/src/datadogV2/model/model_incident_impacts_type.rs
+++ b/src/datadogV2/model/model_incident_impacts_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IncidentImpactsType {
-    #[serde(rename = "incident_impacts")]
     INCIDENT_IMPACTS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for IncidentImpactsType {
         }
     }
 }
+
+impl Serialize for IncidentImpactsType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IncidentImpactsType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "incident_impacts" => Self::INCIDENT_IMPACTS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_incident_integration_metadata_type.rs b/src/datadogV2/model/model_incident_integration_metadata_type.rs
index 149cecca5..af053e042 100644
--- a/src/datadogV2/model/model_incident_integration_metadata_type.rs
+++ b/src/datadogV2/model/model_incident_integration_metadata_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IncidentIntegrationMetadataType {
-    #[serde(rename = "incident_integrations")]
     INCIDENT_INTEGRATIONS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for IncidentIntegrationMetadataType {
         }
     }
 }
+
+impl Serialize for IncidentIntegrationMetadataType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IncidentIntegrationMetadataType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "incident_integrations" => Self::INCIDENT_INTEGRATIONS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_incident_postmortem_type.rs b/src/datadogV2/model/model_incident_postmortem_type.rs
index f9a860f8c..74bce550a 100644
--- a/src/datadogV2/model/model_incident_postmortem_type.rs
+++ b/src/datadogV2/model/model_incident_postmortem_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IncidentPostmortemType {
-    #[serde(rename = "incident_postmortems")]
     INCIDENT_POSTMORTEMS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for IncidentPostmortemType {
         }
     }
 }
+
+impl Serialize for IncidentPostmortemType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IncidentPostmortemType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "incident_postmortems" => Self::INCIDENT_POSTMORTEMS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_incident_related_object.rs b/src/datadogV2/model/model_incident_related_object.rs
index e4009354e..00174534b 100644
--- a/src/datadogV2/model/model_incident_related_object.rs
+++ b/src/datadogV2/model/model_incident_related_object.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IncidentRelatedObject {
-    #[serde(rename = "users")]
     USERS,
-    #[serde(rename = "attachments")]
     ATTACHMENTS,
 }
 
@@ -21,3 +19,33 @@ impl ToString for IncidentRelatedObject {
         }
     }
 }
+
+impl Serialize for IncidentRelatedObject {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IncidentRelatedObject {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "users" => Self::USERS,
+            "attachments" => Self::ATTACHMENTS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_incident_responders_type.rs b/src/datadogV2/model/model_incident_responders_type.rs
index 9cff6c3b1..f855a48ce 100644
--- a/src/datadogV2/model/model_incident_responders_type.rs
+++ b/src/datadogV2/model/model_incident_responders_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IncidentRespondersType {
-    #[serde(rename = "incident_responders")]
     INCIDENT_RESPONDERS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for IncidentRespondersType {
         }
     }
 }
+
+impl Serialize for IncidentRespondersType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IncidentRespondersType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "incident_responders" => Self::INCIDENT_RESPONDERS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_incident_search_results_type.rs b/src/datadogV2/model/model_incident_search_results_type.rs
index 20ef3b599..e7381cede 100644
--- a/src/datadogV2/model/model_incident_search_results_type.rs
+++ b/src/datadogV2/model/model_incident_search_results_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IncidentSearchResultsType {
-    #[serde(rename = "incidents_search_results")]
     INCIDENTS_SEARCH_RESULTS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for IncidentSearchResultsType {
         }
     }
 }
+
+impl Serialize for IncidentSearchResultsType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IncidentSearchResultsType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "incidents_search_results" => Self::INCIDENTS_SEARCH_RESULTS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_incident_search_sort_order.rs b/src/datadogV2/model/model_incident_search_sort_order.rs
index 50235e9b6..cfb0484dd 100644
--- a/src/datadogV2/model/model_incident_search_sort_order.rs
+++ b/src/datadogV2/model/model_incident_search_sort_order.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IncidentSearchSortOrder {
-    #[serde(rename = "created")]
     CREATED_ASCENDING,
-    #[serde(rename = "-created")]
     CREATED_DESCENDING,
 }
 
@@ -21,3 +19,33 @@ impl ToString for IncidentSearchSortOrder {
         }
     }
 }
+
+impl Serialize for IncidentSearchSortOrder {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IncidentSearchSortOrder {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "created" => Self::CREATED_ASCENDING,
+            "-created" => Self::CREATED_DESCENDING,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_incident_service_type.rs b/src/datadogV2/model/model_incident_service_type.rs
index 1250b7d10..bef017721 100644
--- a/src/datadogV2/model/model_incident_service_type.rs
+++ b/src/datadogV2/model/model_incident_service_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IncidentServiceType {
-    #[serde(rename = "services")]
     SERVICES,
 }
 
@@ -18,3 +17,32 @@ impl ToString for IncidentServiceType {
         }
     }
 }
+
+impl Serialize for IncidentServiceType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IncidentServiceType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "services" => Self::SERVICES,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_incident_severity.rs b/src/datadogV2/model/model_incident_severity.rs
index 77803af8a..a5352ae23 100644
--- a/src/datadogV2/model/model_incident_severity.rs
+++ b/src/datadogV2/model/model_incident_severity.rs
@@ -2,22 +2,16 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IncidentSeverity {
-    #[serde(rename = "UNKNOWN")]
     UNKNOWN,
-    #[serde(rename = "SEV-1")]
     SEV_1,
-    #[serde(rename = "SEV-2")]
     SEV_2,
-    #[serde(rename = "SEV-3")]
     SEV_3,
-    #[serde(rename = "SEV-4")]
     SEV_4,
-    #[serde(rename = "SEV-5")]
     SEV_5,
 }
 
@@ -33,3 +27,37 @@ impl ToString for IncidentSeverity {
         }
     }
 }
+
+impl Serialize for IncidentSeverity {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IncidentSeverity {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "UNKNOWN" => Self::UNKNOWN,
+            "SEV-1" => Self::SEV_1,
+            "SEV-2" => Self::SEV_2,
+            "SEV-3" => Self::SEV_3,
+            "SEV-4" => Self::SEV_4,
+            "SEV-5" => Self::SEV_5,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_incident_team_type.rs b/src/datadogV2/model/model_incident_team_type.rs
index 9f809357f..d4dadb1c9 100644
--- a/src/datadogV2/model/model_incident_team_type.rs
+++ b/src/datadogV2/model/model_incident_team_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IncidentTeamType {
-    #[serde(rename = "teams")]
     TEAMS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for IncidentTeamType {
         }
     }
 }
+
+impl Serialize for IncidentTeamType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IncidentTeamType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "teams" => Self::TEAMS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_incident_timeline_cell_markdown_content_type.rs b/src/datadogV2/model/model_incident_timeline_cell_markdown_content_type.rs
index c8ce8dcd7..fc4fc52bf 100644
--- a/src/datadogV2/model/model_incident_timeline_cell_markdown_content_type.rs
+++ b/src/datadogV2/model/model_incident_timeline_cell_markdown_content_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IncidentTimelineCellMarkdownContentType {
-    #[serde(rename = "markdown")]
     MARKDOWN,
 }
 
@@ -18,3 +17,32 @@ impl ToString for IncidentTimelineCellMarkdownContentType {
         }
     }
 }
+
+impl Serialize for IncidentTimelineCellMarkdownContentType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IncidentTimelineCellMarkdownContentType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "markdown" => Self::MARKDOWN,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_incident_todo_anonymous_assignee_source.rs b/src/datadogV2/model/model_incident_todo_anonymous_assignee_source.rs
index f9ca24a20..b2809cfdd 100644
--- a/src/datadogV2/model/model_incident_todo_anonymous_assignee_source.rs
+++ b/src/datadogV2/model/model_incident_todo_anonymous_assignee_source.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IncidentTodoAnonymousAssigneeSource {
-    #[serde(rename = "slack")]
     SLACK,
-    #[serde(rename = "microsoft_teams")]
     MICROSOFT_TEAMS,
 }
 
@@ -21,3 +19,33 @@ impl ToString for IncidentTodoAnonymousAssigneeSource {
         }
     }
 }
+
+impl Serialize for IncidentTodoAnonymousAssigneeSource {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IncidentTodoAnonymousAssigneeSource {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "slack" => Self::SLACK,
+            "microsoft_teams" => Self::MICROSOFT_TEAMS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_incident_todo_type.rs b/src/datadogV2/model/model_incident_todo_type.rs
index 4a19fa08b..f8fe7ccfc 100644
--- a/src/datadogV2/model/model_incident_todo_type.rs
+++ b/src/datadogV2/model/model_incident_todo_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IncidentTodoType {
-    #[serde(rename = "incident_todos")]
     INCIDENT_TODOS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for IncidentTodoType {
         }
     }
 }
+
+impl Serialize for IncidentTodoType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IncidentTodoType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "incident_todos" => Self::INCIDENT_TODOS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_incident_type.rs b/src/datadogV2/model/model_incident_type.rs
index 9bb204e3e..e0264e86a 100644
--- a/src/datadogV2/model/model_incident_type.rs
+++ b/src/datadogV2/model/model_incident_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IncidentType {
-    #[serde(rename = "incidents")]
     INCIDENTS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for IncidentType {
         }
     }
 }
+
+impl Serialize for IncidentType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IncidentType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "incidents" => Self::INCIDENTS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_incident_user_defined_field_type.rs b/src/datadogV2/model/model_incident_user_defined_field_type.rs
index f5230b3c6..a45e26293 100644
--- a/src/datadogV2/model/model_incident_user_defined_field_type.rs
+++ b/src/datadogV2/model/model_incident_user_defined_field_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IncidentUserDefinedFieldType {
-    #[serde(rename = "user_defined_field")]
     USER_DEFINED_FIELD,
 }
 
@@ -18,3 +17,32 @@ impl ToString for IncidentUserDefinedFieldType {
         }
     }
 }
+
+impl Serialize for IncidentUserDefinedFieldType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IncidentUserDefinedFieldType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "user_defined_field" => Self::USER_DEFINED_FIELD,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_ip_allowlist_entry_type.rs b/src/datadogV2/model/model_ip_allowlist_entry_type.rs
index dca44540a..ca02e0d0a 100644
--- a/src/datadogV2/model/model_ip_allowlist_entry_type.rs
+++ b/src/datadogV2/model/model_ip_allowlist_entry_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IPAllowlistEntryType {
-    #[serde(rename = "ip_allowlist_entry")]
     IP_ALLOWLIST_ENTRY,
 }
 
@@ -18,3 +17,32 @@ impl ToString for IPAllowlistEntryType {
         }
     }
 }
+
+impl Serialize for IPAllowlistEntryType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IPAllowlistEntryType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "ip_allowlist_entry" => Self::IP_ALLOWLIST_ENTRY,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_ip_allowlist_type.rs b/src/datadogV2/model/model_ip_allowlist_type.rs
index 9f61fce3c..99fd4dd2d 100644
--- a/src/datadogV2/model/model_ip_allowlist_type.rs
+++ b/src/datadogV2/model/model_ip_allowlist_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IPAllowlistType {
-    #[serde(rename = "ip_allowlist")]
     IP_ALLOWLIST,
 }
 
@@ -18,3 +17,32 @@ impl ToString for IPAllowlistType {
         }
     }
 }
+
+impl Serialize for IPAllowlistType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for IPAllowlistType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "ip_allowlist" => Self::IP_ALLOWLIST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_list_teams_include.rs b/src/datadogV2/model/model_list_teams_include.rs
index 7e7c6d8fc..4d027e2d0 100644
--- a/src/datadogV2/model/model_list_teams_include.rs
+++ b/src/datadogV2/model/model_list_teams_include.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ListTeamsInclude {
-    #[serde(rename = "team_links")]
     TEAM_LINKS,
-    #[serde(rename = "user_team_permissions")]
     USER_TEAM_PERMISSIONS,
 }
 
@@ -21,3 +19,33 @@ impl ToString for ListTeamsInclude {
         }
     }
 }
+
+impl Serialize for ListTeamsInclude {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ListTeamsInclude {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "team_links" => Self::TEAM_LINKS,
+            "user_team_permissions" => Self::USER_TEAM_PERMISSIONS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_list_teams_sort.rs b/src/datadogV2/model/model_list_teams_sort.rs
index a2e597882..4cf0f584e 100644
--- a/src/datadogV2/model/model_list_teams_sort.rs
+++ b/src/datadogV2/model/model_list_teams_sort.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ListTeamsSort {
-    #[serde(rename = "name")]
     NAME,
-    #[serde(rename = "-name")]
     _NAME,
-    #[serde(rename = "user_count")]
     USER_COUNT,
-    #[serde(rename = "-user_count")]
     _USER_COUNT,
 }
 
@@ -27,3 +23,35 @@ impl ToString for ListTeamsSort {
         }
     }
 }
+
+impl Serialize for ListTeamsSort {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ListTeamsSort {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "name" => Self::NAME,
+            "-name" => Self::_NAME,
+            "user_count" => Self::USER_COUNT,
+            "-user_count" => Self::_USER_COUNT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_log_type.rs b/src/datadogV2/model/model_log_type.rs
index 763bda4dd..90041888d 100644
--- a/src/datadogV2/model/model_log_type.rs
+++ b/src/datadogV2/model/model_log_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogType {
-    #[serde(rename = "log")]
     LOG,
 }
 
@@ -18,3 +17,32 @@ impl ToString for LogType {
         }
     }
 }
+
+impl Serialize for LogType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "log" => Self::LOG,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_logs_aggregate_response_status.rs b/src/datadogV2/model/model_logs_aggregate_response_status.rs
index 0fe3ca12f..dd545119f 100644
--- a/src/datadogV2/model/model_logs_aggregate_response_status.rs
+++ b/src/datadogV2/model/model_logs_aggregate_response_status.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsAggregateResponseStatus {
-    #[serde(rename = "done")]
     DONE,
-    #[serde(rename = "timeout")]
     TIMEOUT,
 }
 
@@ -21,3 +19,33 @@ impl ToString for LogsAggregateResponseStatus {
         }
     }
 }
+
+impl Serialize for LogsAggregateResponseStatus {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsAggregateResponseStatus {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "done" => Self::DONE,
+            "timeout" => Self::TIMEOUT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_logs_aggregate_sort_type.rs b/src/datadogV2/model/model_logs_aggregate_sort_type.rs
index 97ee1f00b..e041d6d11 100644
--- a/src/datadogV2/model/model_logs_aggregate_sort_type.rs
+++ b/src/datadogV2/model/model_logs_aggregate_sort_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsAggregateSortType {
-    #[serde(rename = "alphabetical")]
     ALPHABETICAL,
-    #[serde(rename = "measure")]
     MEASURE,
 }
 
@@ -21,3 +19,33 @@ impl ToString for LogsAggregateSortType {
         }
     }
 }
+
+impl Serialize for LogsAggregateSortType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsAggregateSortType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "alphabetical" => Self::ALPHABETICAL,
+            "measure" => Self::MEASURE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_logs_aggregation_function.rs b/src/datadogV2/model/model_logs_aggregation_function.rs
index 795a40ad5..caa88e3c9 100644
--- a/src/datadogV2/model/model_logs_aggregation_function.rs
+++ b/src/datadogV2/model/model_logs_aggregation_function.rs
@@ -2,34 +2,22 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsAggregationFunction {
-    #[serde(rename = "count")]
     COUNT,
-    #[serde(rename = "cardinality")]
     CARDINALITY,
-    #[serde(rename = "pc75")]
     PERCENTILE_75,
-    #[serde(rename = "pc90")]
     PERCENTILE_90,
-    #[serde(rename = "pc95")]
     PERCENTILE_95,
-    #[serde(rename = "pc98")]
     PERCENTILE_98,
-    #[serde(rename = "pc99")]
     PERCENTILE_99,
-    #[serde(rename = "sum")]
     SUM,
-    #[serde(rename = "min")]
     MIN,
-    #[serde(rename = "max")]
     MAX,
-    #[serde(rename = "avg")]
     AVG,
-    #[serde(rename = "median")]
     MEDIAN,
 }
 
@@ -51,3 +39,43 @@ impl ToString for LogsAggregationFunction {
         }
     }
 }
+
+impl Serialize for LogsAggregationFunction {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsAggregationFunction {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "count" => Self::COUNT,
+            "cardinality" => Self::CARDINALITY,
+            "pc75" => Self::PERCENTILE_75,
+            "pc90" => Self::PERCENTILE_90,
+            "pc95" => Self::PERCENTILE_95,
+            "pc98" => Self::PERCENTILE_98,
+            "pc99" => Self::PERCENTILE_99,
+            "sum" => Self::SUM,
+            "min" => Self::MIN,
+            "max" => Self::MAX,
+            "avg" => Self::AVG,
+            "median" => Self::MEDIAN,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_logs_archive_destination_azure_type.rs b/src/datadogV2/model/model_logs_archive_destination_azure_type.rs
index 17ae28d0f..aeb91c79b 100644
--- a/src/datadogV2/model/model_logs_archive_destination_azure_type.rs
+++ b/src/datadogV2/model/model_logs_archive_destination_azure_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsArchiveDestinationAzureType {
-    #[serde(rename = "azure")]
     AZURE,
 }
 
@@ -18,3 +17,32 @@ impl ToString for LogsArchiveDestinationAzureType {
         }
     }
 }
+
+impl Serialize for LogsArchiveDestinationAzureType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsArchiveDestinationAzureType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "azure" => Self::AZURE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_logs_archive_destination_gcs_type.rs b/src/datadogV2/model/model_logs_archive_destination_gcs_type.rs
index 878ad6852..60adc086a 100644
--- a/src/datadogV2/model/model_logs_archive_destination_gcs_type.rs
+++ b/src/datadogV2/model/model_logs_archive_destination_gcs_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsArchiveDestinationGCSType {
-    #[serde(rename = "gcs")]
     GCS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for LogsArchiveDestinationGCSType {
         }
     }
 }
+
+impl Serialize for LogsArchiveDestinationGCSType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsArchiveDestinationGCSType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "gcs" => Self::GCS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_logs_archive_destination_s3_type.rs b/src/datadogV2/model/model_logs_archive_destination_s3_type.rs
index 01b4e75d2..7e6772c0c 100644
--- a/src/datadogV2/model/model_logs_archive_destination_s3_type.rs
+++ b/src/datadogV2/model/model_logs_archive_destination_s3_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsArchiveDestinationS3Type {
-    #[serde(rename = "s3")]
     S3,
 }
 
@@ -18,3 +17,32 @@ impl ToString for LogsArchiveDestinationS3Type {
         }
     }
 }
+
+impl Serialize for LogsArchiveDestinationS3Type {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsArchiveDestinationS3Type {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "s3" => Self::S3,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_logs_archive_order_definition_type.rs b/src/datadogV2/model/model_logs_archive_order_definition_type.rs
index 661fb2ef2..ebca068e0 100644
--- a/src/datadogV2/model/model_logs_archive_order_definition_type.rs
+++ b/src/datadogV2/model/model_logs_archive_order_definition_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsArchiveOrderDefinitionType {
-    #[serde(rename = "archive_order")]
     ARCHIVE_ORDER,
 }
 
@@ -18,3 +17,32 @@ impl ToString for LogsArchiveOrderDefinitionType {
         }
     }
 }
+
+impl Serialize for LogsArchiveOrderDefinitionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsArchiveOrderDefinitionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "archive_order" => Self::ARCHIVE_ORDER,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_logs_archive_state.rs b/src/datadogV2/model/model_logs_archive_state.rs
index 3c6183d44..84c2e0967 100644
--- a/src/datadogV2/model/model_logs_archive_state.rs
+++ b/src/datadogV2/model/model_logs_archive_state.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsArchiveState {
-    #[serde(rename = "UNKNOWN")]
     UNKNOWN,
-    #[serde(rename = "WORKING")]
     WORKING,
-    #[serde(rename = "FAILING")]
     FAILING,
-    #[serde(rename = "WORKING_AUTH_LEGACY")]
     WORKING_AUTH_LEGACY,
 }
 
@@ -27,3 +23,35 @@ impl ToString for LogsArchiveState {
         }
     }
 }
+
+impl Serialize for LogsArchiveState {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsArchiveState {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "UNKNOWN" => Self::UNKNOWN,
+            "WORKING" => Self::WORKING,
+            "FAILING" => Self::FAILING,
+            "WORKING_AUTH_LEGACY" => Self::WORKING_AUTH_LEGACY,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_logs_compute_type.rs b/src/datadogV2/model/model_logs_compute_type.rs
index 6040ab5b5..a002b9fca 100644
--- a/src/datadogV2/model/model_logs_compute_type.rs
+++ b/src/datadogV2/model/model_logs_compute_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsComputeType {
-    #[serde(rename = "timeseries")]
     TIMESERIES,
-    #[serde(rename = "total")]
     TOTAL,
 }
 
@@ -21,3 +19,33 @@ impl ToString for LogsComputeType {
         }
     }
 }
+
+impl Serialize for LogsComputeType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsComputeType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "timeseries" => Self::TIMESERIES,
+            "total" => Self::TOTAL,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_logs_metric_compute_aggregation_type.rs b/src/datadogV2/model/model_logs_metric_compute_aggregation_type.rs
index 09444e6a8..76405cb1c 100644
--- a/src/datadogV2/model/model_logs_metric_compute_aggregation_type.rs
+++ b/src/datadogV2/model/model_logs_metric_compute_aggregation_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsMetricComputeAggregationType {
-    #[serde(rename = "count")]
     COUNT,
-    #[serde(rename = "distribution")]
     DISTRIBUTION,
 }
 
@@ -21,3 +19,33 @@ impl ToString for LogsMetricComputeAggregationType {
         }
     }
 }
+
+impl Serialize for LogsMetricComputeAggregationType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsMetricComputeAggregationType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "count" => Self::COUNT,
+            "distribution" => Self::DISTRIBUTION,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_logs_metric_response_compute_aggregation_type.rs b/src/datadogV2/model/model_logs_metric_response_compute_aggregation_type.rs
index 6cb57eda4..251aa707e 100644
--- a/src/datadogV2/model/model_logs_metric_response_compute_aggregation_type.rs
+++ b/src/datadogV2/model/model_logs_metric_response_compute_aggregation_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsMetricResponseComputeAggregationType {
-    #[serde(rename = "count")]
     COUNT,
-    #[serde(rename = "distribution")]
     DISTRIBUTION,
 }
 
@@ -21,3 +19,33 @@ impl ToString for LogsMetricResponseComputeAggregationType {
         }
     }
 }
+
+impl Serialize for LogsMetricResponseComputeAggregationType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsMetricResponseComputeAggregationType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "count" => Self::COUNT,
+            "distribution" => Self::DISTRIBUTION,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_logs_metric_type.rs b/src/datadogV2/model/model_logs_metric_type.rs
index 3ba90d8e7..d122f81ef 100644
--- a/src/datadogV2/model/model_logs_metric_type.rs
+++ b/src/datadogV2/model/model_logs_metric_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsMetricType {
-    #[serde(rename = "logs_metrics")]
     LOGS_METRICS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for LogsMetricType {
         }
     }
 }
+
+impl Serialize for LogsMetricType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsMetricType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "logs_metrics" => Self::LOGS_METRICS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_logs_sort.rs b/src/datadogV2/model/model_logs_sort.rs
index 79720f577..e6902dbe0 100644
--- a/src/datadogV2/model/model_logs_sort.rs
+++ b/src/datadogV2/model/model_logs_sort.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsSort {
-    #[serde(rename = "timestamp")]
     TIMESTAMP_ASCENDING,
-    #[serde(rename = "-timestamp")]
     TIMESTAMP_DESCENDING,
 }
 
@@ -21,3 +19,33 @@ impl ToString for LogsSort {
         }
     }
 }
+
+impl Serialize for LogsSort {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsSort {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "timestamp" => Self::TIMESTAMP_ASCENDING,
+            "-timestamp" => Self::TIMESTAMP_DESCENDING,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_logs_sort_order.rs b/src/datadogV2/model/model_logs_sort_order.rs
index 86241a52b..f6dd92d5c 100644
--- a/src/datadogV2/model/model_logs_sort_order.rs
+++ b/src/datadogV2/model/model_logs_sort_order.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsSortOrder {
-    #[serde(rename = "asc")]
     ASCENDING,
-    #[serde(rename = "desc")]
     DESCENDING,
 }
 
@@ -21,3 +19,33 @@ impl ToString for LogsSortOrder {
         }
     }
 }
+
+impl Serialize for LogsSortOrder {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsSortOrder {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "asc" => Self::ASCENDING,
+            "desc" => Self::DESCENDING,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_logs_storage_tier.rs b/src/datadogV2/model/model_logs_storage_tier.rs
index 45f9ccfc3..7a823a66e 100644
--- a/src/datadogV2/model/model_logs_storage_tier.rs
+++ b/src/datadogV2/model/model_logs_storage_tier.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum LogsStorageTier {
-    #[serde(rename = "indexes")]
     INDEXES,
-    #[serde(rename = "online-archives")]
     ONLINE_ARCHIVES,
 }
 
@@ -21,3 +19,33 @@ impl ToString for LogsStorageTier {
         }
     }
 }
+
+impl Serialize for LogsStorageTier {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogsStorageTier {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "indexes" => Self::INDEXES,
+            "online-archives" => Self::ONLINE_ARCHIVES,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_metric_active_configuration_type.rs b/src/datadogV2/model/model_metric_active_configuration_type.rs
index 429860cdf..c6ed392a8 100644
--- a/src/datadogV2/model/model_metric_active_configuration_type.rs
+++ b/src/datadogV2/model/model_metric_active_configuration_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MetricActiveConfigurationType {
-    #[serde(rename = "actively_queried_configurations")]
     ACTIVELY_QUERIED_CONFIGURATIONS,
 }
 
@@ -20,3 +19,32 @@ impl ToString for MetricActiveConfigurationType {
         }
     }
 }
+
+impl Serialize for MetricActiveConfigurationType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MetricActiveConfigurationType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "actively_queried_configurations" => Self::ACTIVELY_QUERIED_CONFIGURATIONS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_metric_bulk_configure_tags_type.rs b/src/datadogV2/model/model_metric_bulk_configure_tags_type.rs
index 8fcf0f070..b629f7925 100644
--- a/src/datadogV2/model/model_metric_bulk_configure_tags_type.rs
+++ b/src/datadogV2/model/model_metric_bulk_configure_tags_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MetricBulkConfigureTagsType {
-    #[serde(rename = "metric_bulk_configure_tags")]
     BULK_MANAGE_TAGS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for MetricBulkConfigureTagsType {
         }
     }
 }
+
+impl Serialize for MetricBulkConfigureTagsType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MetricBulkConfigureTagsType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "metric_bulk_configure_tags" => Self::BULK_MANAGE_TAGS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_metric_content_encoding.rs b/src/datadogV2/model/model_metric_content_encoding.rs
index abddbc2ac..91c3cffac 100644
--- a/src/datadogV2/model/model_metric_content_encoding.rs
+++ b/src/datadogV2/model/model_metric_content_encoding.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MetricContentEncoding {
-    #[serde(rename = "deflate")]
     DEFLATE,
-    #[serde(rename = "zstd1")]
     ZSTD1,
-    #[serde(rename = "gzip")]
     GZIP,
 }
 
@@ -24,3 +21,34 @@ impl ToString for MetricContentEncoding {
         }
     }
 }
+
+impl Serialize for MetricContentEncoding {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MetricContentEncoding {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "deflate" => Self::DEFLATE,
+            "zstd1" => Self::ZSTD1,
+            "gzip" => Self::GZIP,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_metric_custom_space_aggregation.rs b/src/datadogV2/model/model_metric_custom_space_aggregation.rs
index 1122f16d3..e94bd7c84 100644
--- a/src/datadogV2/model/model_metric_custom_space_aggregation.rs
+++ b/src/datadogV2/model/model_metric_custom_space_aggregation.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MetricCustomSpaceAggregation {
-    #[serde(rename = "avg")]
     AVG,
-    #[serde(rename = "max")]
     MAX,
-    #[serde(rename = "min")]
     MIN,
-    #[serde(rename = "sum")]
     SUM,
 }
 
@@ -27,3 +23,35 @@ impl ToString for MetricCustomSpaceAggregation {
         }
     }
 }
+
+impl Serialize for MetricCustomSpaceAggregation {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MetricCustomSpaceAggregation {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "avg" => Self::AVG,
+            "max" => Self::MAX,
+            "min" => Self::MIN,
+            "sum" => Self::SUM,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_metric_custom_time_aggregation.rs b/src/datadogV2/model/model_metric_custom_time_aggregation.rs
index 654e01f16..cf7bb9021 100644
--- a/src/datadogV2/model/model_metric_custom_time_aggregation.rs
+++ b/src/datadogV2/model/model_metric_custom_time_aggregation.rs
@@ -2,20 +2,15 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MetricCustomTimeAggregation {
-    #[serde(rename = "avg")]
     AVG,
-    #[serde(rename = "count")]
     COUNT,
-    #[serde(rename = "max")]
     MAX,
-    #[serde(rename = "min")]
     MIN,
-    #[serde(rename = "sum")]
     SUM,
 }
 
@@ -30,3 +25,36 @@ impl ToString for MetricCustomTimeAggregation {
         }
     }
 }
+
+impl Serialize for MetricCustomTimeAggregation {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MetricCustomTimeAggregation {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "avg" => Self::AVG,
+            "count" => Self::COUNT,
+            "max" => Self::MAX,
+            "min" => Self::MIN,
+            "sum" => Self::SUM,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_metric_distinct_volume_type.rs b/src/datadogV2/model/model_metric_distinct_volume_type.rs
index f30ba286c..0d56d8f86 100644
--- a/src/datadogV2/model/model_metric_distinct_volume_type.rs
+++ b/src/datadogV2/model/model_metric_distinct_volume_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MetricDistinctVolumeType {
-    #[serde(rename = "distinct_metric_volumes")]
     DISTINCT_METRIC_VOLUMES,
 }
 
@@ -18,3 +17,32 @@ impl ToString for MetricDistinctVolumeType {
         }
     }
 }
+
+impl Serialize for MetricDistinctVolumeType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MetricDistinctVolumeType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "distinct_metric_volumes" => Self::DISTINCT_METRIC_VOLUMES,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_metric_estimate_resource_type.rs b/src/datadogV2/model/model_metric_estimate_resource_type.rs
index 887959771..916eceea5 100644
--- a/src/datadogV2/model/model_metric_estimate_resource_type.rs
+++ b/src/datadogV2/model/model_metric_estimate_resource_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MetricEstimateResourceType {
-    #[serde(rename = "metric_cardinality_estimate")]
     METRIC_CARDINALITY_ESTIMATE,
 }
 
@@ -18,3 +17,32 @@ impl ToString for MetricEstimateResourceType {
         }
     }
 }
+
+impl Serialize for MetricEstimateResourceType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MetricEstimateResourceType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "metric_cardinality_estimate" => Self::METRIC_CARDINALITY_ESTIMATE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_metric_estimate_type.rs b/src/datadogV2/model/model_metric_estimate_type.rs
index e14f1dafe..67513be06 100644
--- a/src/datadogV2/model/model_metric_estimate_type.rs
+++ b/src/datadogV2/model/model_metric_estimate_type.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MetricEstimateType {
-    #[serde(rename = "count_or_gauge")]
     COUNT_OR_GAUGE,
-    #[serde(rename = "distribution")]
     DISTRIBUTION,
-    #[serde(rename = "percentile")]
     PERCENTILE,
 }
 
@@ -24,3 +21,34 @@ impl ToString for MetricEstimateType {
         }
     }
 }
+
+impl Serialize for MetricEstimateType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MetricEstimateType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "count_or_gauge" => Self::COUNT_OR_GAUGE,
+            "distribution" => Self::DISTRIBUTION,
+            "percentile" => Self::PERCENTILE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_metric_ingested_indexed_volume_type.rs b/src/datadogV2/model/model_metric_ingested_indexed_volume_type.rs
index c1e1d3a61..a1e88e871 100644
--- a/src/datadogV2/model/model_metric_ingested_indexed_volume_type.rs
+++ b/src/datadogV2/model/model_metric_ingested_indexed_volume_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MetricIngestedIndexedVolumeType {
-    #[serde(rename = "metric_volumes")]
     METRIC_VOLUMES,
 }
 
@@ -18,3 +17,32 @@ impl ToString for MetricIngestedIndexedVolumeType {
         }
     }
 }
+
+impl Serialize for MetricIngestedIndexedVolumeType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MetricIngestedIndexedVolumeType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "metric_volumes" => Self::METRIC_VOLUMES,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_metric_intake_type.rs b/src/datadogV2/model/model_metric_intake_type.rs
index 51759d449..18e7af6b5 100644
--- a/src/datadogV2/model/model_metric_intake_type.rs
+++ b/src/datadogV2/model/model_metric_intake_type.rs
@@ -2,27 +2,48 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde_repr::{Deserialize_repr, Serialize_repr};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(
-    Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize_repr, Deserialize_repr,
-)]
-#[repr(i32)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MetricIntakeType {
-    UNSPECIFIED = 0,
-    COUNT = 1,
-    RATE = 2,
-    GAUGE = 3,
+    UNSPECIFIED,
+    COUNT,
+    RATE,
+    GAUGE,
 }
 
-impl ToString for MetricIntakeType {
-    fn to_string(&self) -> String {
+impl Serialize for MetricIntakeType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
         match self {
-            Self::UNSPECIFIED => String::from("0"),
-            Self::COUNT => String::from("1"),
-            Self::RATE => String::from("2"),
-            Self::GAUGE => String::from("3"),
+            Self::UNSPECIFIED => serializer.serialize_i32(0),
+            Self::COUNT => serializer.serialize_i32(1),
+            Self::RATE => serializer.serialize_i32(2),
+            Self::GAUGE => serializer.serialize_i32(3),
         }
     }
 }
+
+impl<'de> Deserialize<'de> for MetricIntakeType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: i32 = i32::deserialize(deserializer)?;
+        Ok(match s {
+            0 => Self::UNSPECIFIED,
+            1 => Self::COUNT,
+            2 => Self::RATE,
+            3 => Self::GAUGE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_metric_tag_configuration_metric_types.rs b/src/datadogV2/model/model_metric_tag_configuration_metric_types.rs
index a16eb88e5..134354bae 100644
--- a/src/datadogV2/model/model_metric_tag_configuration_metric_types.rs
+++ b/src/datadogV2/model/model_metric_tag_configuration_metric_types.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MetricTagConfigurationMetricTypes {
-    #[serde(rename = "gauge")]
     GAUGE,
-    #[serde(rename = "count")]
     COUNT,
-    #[serde(rename = "rate")]
     RATE,
-    #[serde(rename = "distribution")]
     DISTRIBUTION,
 }
 
@@ -27,3 +23,35 @@ impl ToString for MetricTagConfigurationMetricTypes {
         }
     }
 }
+
+impl Serialize for MetricTagConfigurationMetricTypes {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MetricTagConfigurationMetricTypes {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "gauge" => Self::GAUGE,
+            "count" => Self::COUNT,
+            "rate" => Self::RATE,
+            "distribution" => Self::DISTRIBUTION,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_metric_tag_configuration_type.rs b/src/datadogV2/model/model_metric_tag_configuration_type.rs
index 9d46bd76a..35a1353b4 100644
--- a/src/datadogV2/model/model_metric_tag_configuration_type.rs
+++ b/src/datadogV2/model/model_metric_tag_configuration_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MetricTagConfigurationType {
-    #[serde(rename = "manage_tags")]
     MANAGE_TAGS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for MetricTagConfigurationType {
         }
     }
 }
+
+impl Serialize for MetricTagConfigurationType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MetricTagConfigurationType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "manage_tags" => Self::MANAGE_TAGS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_metric_type.rs b/src/datadogV2/model/model_metric_type.rs
index 11cf43903..5a7e95940 100644
--- a/src/datadogV2/model/model_metric_type.rs
+++ b/src/datadogV2/model/model_metric_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MetricType {
-    #[serde(rename = "metrics")]
     METRICS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for MetricType {
         }
     }
 }
+
+impl Serialize for MetricType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MetricType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "metrics" => Self::METRICS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_metrics_aggregator.rs b/src/datadogV2/model/model_metrics_aggregator.rs
index bf284c3f7..73bf8d860 100644
--- a/src/datadogV2/model/model_metrics_aggregator.rs
+++ b/src/datadogV2/model/model_metrics_aggregator.rs
@@ -2,28 +2,19 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MetricsAggregator {
-    #[serde(rename = "avg")]
     AVG,
-    #[serde(rename = "min")]
     MIN,
-    #[serde(rename = "max")]
     MAX,
-    #[serde(rename = "sum")]
     SUM,
-    #[serde(rename = "last")]
     LAST,
-    #[serde(rename = "percentile")]
     PERCENTILE,
-    #[serde(rename = "mean")]
     MEAN,
-    #[serde(rename = "l2norm")]
     L2NORM,
-    #[serde(rename = "area")]
     AREA,
 }
 
@@ -42,3 +33,40 @@ impl ToString for MetricsAggregator {
         }
     }
 }
+
+impl Serialize for MetricsAggregator {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MetricsAggregator {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "avg" => Self::AVG,
+            "min" => Self::MIN,
+            "max" => Self::MAX,
+            "sum" => Self::SUM,
+            "last" => Self::LAST,
+            "percentile" => Self::PERCENTILE,
+            "mean" => Self::MEAN,
+            "l2norm" => Self::L2NORM,
+            "area" => Self::AREA,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_metrics_data_source.rs b/src/datadogV2/model/model_metrics_data_source.rs
index dbd1854b9..8921da6de 100644
--- a/src/datadogV2/model/model_metrics_data_source.rs
+++ b/src/datadogV2/model/model_metrics_data_source.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MetricsDataSource {
-    #[serde(rename = "metrics")]
     METRICS,
-    #[serde(rename = "cloud_cost")]
     CLOUD_COST,
 }
 
@@ -21,3 +19,33 @@ impl ToString for MetricsDataSource {
         }
     }
 }
+
+impl Serialize for MetricsDataSource {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MetricsDataSource {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "metrics" => Self::METRICS,
+            "cloud_cost" => Self::CLOUD_COST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_monitor_config_policy_resource_type.rs b/src/datadogV2/model/model_monitor_config_policy_resource_type.rs
index fdc913a9f..f484b036f 100644
--- a/src/datadogV2/model/model_monitor_config_policy_resource_type.rs
+++ b/src/datadogV2/model/model_monitor_config_policy_resource_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MonitorConfigPolicyResourceType {
-    #[serde(rename = "monitor-config-policy")]
     MONITOR_CONFIG_POLICY,
 }
 
@@ -18,3 +17,32 @@ impl ToString for MonitorConfigPolicyResourceType {
         }
     }
 }
+
+impl Serialize for MonitorConfigPolicyResourceType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MonitorConfigPolicyResourceType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "monitor-config-policy" => Self::MONITOR_CONFIG_POLICY,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_monitor_config_policy_type.rs b/src/datadogV2/model/model_monitor_config_policy_type.rs
index 1b01539c5..f6482c186 100644
--- a/src/datadogV2/model/model_monitor_config_policy_type.rs
+++ b/src/datadogV2/model/model_monitor_config_policy_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MonitorConfigPolicyType {
-    #[serde(rename = "tag")]
     TAG,
 }
 
@@ -18,3 +17,32 @@ impl ToString for MonitorConfigPolicyType {
         }
     }
 }
+
+impl Serialize for MonitorConfigPolicyType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MonitorConfigPolicyType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "tag" => Self::TAG,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_monitor_downtime_match_resource_type.rs b/src/datadogV2/model/model_monitor_downtime_match_resource_type.rs
index 72203ad5d..6e8a0ef1b 100644
--- a/src/datadogV2/model/model_monitor_downtime_match_resource_type.rs
+++ b/src/datadogV2/model/model_monitor_downtime_match_resource_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MonitorDowntimeMatchResourceType {
-    #[serde(rename = "downtime_match")]
     DOWNTIME_MATCH,
 }
 
@@ -18,3 +17,32 @@ impl ToString for MonitorDowntimeMatchResourceType {
         }
     }
 }
+
+impl Serialize for MonitorDowntimeMatchResourceType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for MonitorDowntimeMatchResourceType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "downtime_match" => Self::DOWNTIME_MATCH,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_okta_account_type.rs b/src/datadogV2/model/model_okta_account_type.rs
index d946e8667..867367fa9 100644
--- a/src/datadogV2/model/model_okta_account_type.rs
+++ b/src/datadogV2/model/model_okta_account_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum OktaAccountType {
-    #[serde(rename = "okta-accounts")]
     OKTA_ACCOUNTS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for OktaAccountType {
         }
     }
 }
+
+impl Serialize for OktaAccountType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for OktaAccountType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "okta-accounts" => Self::OKTA_ACCOUNTS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_on_demand_concurrency_cap_type.rs b/src/datadogV2/model/model_on_demand_concurrency_cap_type.rs
index b07eda9f8..20b956b95 100644
--- a/src/datadogV2/model/model_on_demand_concurrency_cap_type.rs
+++ b/src/datadogV2/model/model_on_demand_concurrency_cap_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum OnDemandConcurrencyCapType {
-    #[serde(rename = "on_demand_concurrency_cap")]
     ON_DEMAND_CONCURRENCY_CAP,
 }
 
@@ -18,3 +17,32 @@ impl ToString for OnDemandConcurrencyCapType {
         }
     }
 }
+
+impl Serialize for OnDemandConcurrencyCapType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for OnDemandConcurrencyCapType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "on_demand_concurrency_cap" => Self::ON_DEMAND_CONCURRENCY_CAP,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_opsgenie_service_region_type.rs b/src/datadogV2/model/model_opsgenie_service_region_type.rs
index 998950fa8..8d65913d8 100644
--- a/src/datadogV2/model/model_opsgenie_service_region_type.rs
+++ b/src/datadogV2/model/model_opsgenie_service_region_type.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum OpsgenieServiceRegionType {
-    #[serde(rename = "us")]
     US,
-    #[serde(rename = "eu")]
     EU,
-    #[serde(rename = "custom")]
     CUSTOM,
 }
 
@@ -24,3 +21,34 @@ impl ToString for OpsgenieServiceRegionType {
         }
     }
 }
+
+impl Serialize for OpsgenieServiceRegionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for OpsgenieServiceRegionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "us" => Self::US,
+            "eu" => Self::EU,
+            "custom" => Self::CUSTOM,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_opsgenie_service_type.rs b/src/datadogV2/model/model_opsgenie_service_type.rs
index a609c76d8..dfd562412 100644
--- a/src/datadogV2/model/model_opsgenie_service_type.rs
+++ b/src/datadogV2/model/model_opsgenie_service_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum OpsgenieServiceType {
-    #[serde(rename = "opsgenie-service")]
     OPSGENIE_SERVICE,
 }
 
@@ -18,3 +17,32 @@ impl ToString for OpsgenieServiceType {
         }
     }
 }
+
+impl Serialize for OpsgenieServiceType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for OpsgenieServiceType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "opsgenie-service" => Self::OPSGENIE_SERVICE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_organizations_type.rs b/src/datadogV2/model/model_organizations_type.rs
index ed903e512..ea0a75189 100644
--- a/src/datadogV2/model/model_organizations_type.rs
+++ b/src/datadogV2/model/model_organizations_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum OrganizationsType {
-    #[serde(rename = "orgs")]
     ORGS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for OrganizationsType {
         }
     }
 }
+
+impl Serialize for OrganizationsType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for OrganizationsType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "orgs" => Self::ORGS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_outcome_type.rs b/src/datadogV2/model/model_outcome_type.rs
index 146903c45..a10ae5fde 100644
--- a/src/datadogV2/model/model_outcome_type.rs
+++ b/src/datadogV2/model/model_outcome_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum OutcomeType {
-    #[serde(rename = "outcome")]
     OUTCOME,
 }
 
@@ -18,3 +17,32 @@ impl ToString for OutcomeType {
         }
     }
 }
+
+impl Serialize for OutcomeType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for OutcomeType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "outcome" => Self::OUTCOME,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_outcomes_batch_type.rs b/src/datadogV2/model/model_outcomes_batch_type.rs
index f983e75d9..4492c6a25 100644
--- a/src/datadogV2/model/model_outcomes_batch_type.rs
+++ b/src/datadogV2/model/model_outcomes_batch_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum OutcomesBatchType {
-    #[serde(rename = "batched-outcome")]
     BATCHED_OUTCOME,
 }
 
@@ -18,3 +17,32 @@ impl ToString for OutcomesBatchType {
         }
     }
 }
+
+impl Serialize for OutcomesBatchType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for OutcomesBatchType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "batched-outcome" => Self::BATCHED_OUTCOME,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_permissions_type.rs b/src/datadogV2/model/model_permissions_type.rs
index c47379b2f..80450104e 100644
--- a/src/datadogV2/model/model_permissions_type.rs
+++ b/src/datadogV2/model/model_permissions_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum PermissionsType {
-    #[serde(rename = "permissions")]
     PERMISSIONS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for PermissionsType {
         }
     }
 }
+
+impl Serialize for PermissionsType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for PermissionsType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "permissions" => Self::PERMISSIONS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_process_summary_type.rs b/src/datadogV2/model/model_process_summary_type.rs
index f694d3f0f..558a6beaa 100644
--- a/src/datadogV2/model/model_process_summary_type.rs
+++ b/src/datadogV2/model/model_process_summary_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ProcessSummaryType {
-    #[serde(rename = "process")]
     PROCESS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ProcessSummaryType {
         }
     }
 }
+
+impl Serialize for ProcessSummaryType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ProcessSummaryType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "process" => Self::PROCESS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_projected_cost_type.rs b/src/datadogV2/model/model_projected_cost_type.rs
index ca4db36d0..411c35d1e 100644
--- a/src/datadogV2/model/model_projected_cost_type.rs
+++ b/src/datadogV2/model/model_projected_cost_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ProjectedCostType {
-    #[serde(rename = "projected_cost")]
     PROJECt_COST,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ProjectedCostType {
         }
     }
 }
+
+impl Serialize for ProjectedCostType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ProjectedCostType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "projected_cost" => Self::PROJECt_COST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_query_sort_order.rs b/src/datadogV2/model/model_query_sort_order.rs
index 7d458d6f7..42f236175 100644
--- a/src/datadogV2/model/model_query_sort_order.rs
+++ b/src/datadogV2/model/model_query_sort_order.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum QuerySortOrder {
-    #[serde(rename = "asc")]
     ASC,
-    #[serde(rename = "desc")]
     DESC,
 }
 
@@ -21,3 +19,33 @@ impl ToString for QuerySortOrder {
         }
     }
 }
+
+impl Serialize for QuerySortOrder {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for QuerySortOrder {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "asc" => Self::ASC,
+            "desc" => Self::DESC,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_restriction_policy_type.rs b/src/datadogV2/model/model_restriction_policy_type.rs
index 9cb418aba..a775184c2 100644
--- a/src/datadogV2/model/model_restriction_policy_type.rs
+++ b/src/datadogV2/model/model_restriction_policy_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum RestrictionPolicyType {
-    #[serde(rename = "restriction_policy")]
     RESTRICTION_POLICY,
 }
 
@@ -18,3 +17,32 @@ impl ToString for RestrictionPolicyType {
         }
     }
 }
+
+impl Serialize for RestrictionPolicyType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for RestrictionPolicyType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "restriction_policy" => Self::RESTRICTION_POLICY,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_retention_filter_all_type.rs b/src/datadogV2/model/model_retention_filter_all_type.rs
index 196ec77af..b515b8272 100644
--- a/src/datadogV2/model/model_retention_filter_all_type.rs
+++ b/src/datadogV2/model/model_retention_filter_all_type.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum RetentionFilterAllType {
-    #[serde(rename = "spans-sampling-processor")]
     SPANS_SAMPLING_PROCESSOR,
-    #[serde(rename = "spans-errors-sampling-processor")]
     SPANS_ERRORS_SAMPLING_PROCESSOR,
-    #[serde(rename = "spans-appsec-sampling-processor")]
     SPANS_APPSEC_SAMPLING_PROCESSOR,
 }
 
@@ -28,3 +25,34 @@ impl ToString for RetentionFilterAllType {
         }
     }
 }
+
+impl Serialize for RetentionFilterAllType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for RetentionFilterAllType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "spans-sampling-processor" => Self::SPANS_SAMPLING_PROCESSOR,
+            "spans-errors-sampling-processor" => Self::SPANS_ERRORS_SAMPLING_PROCESSOR,
+            "spans-appsec-sampling-processor" => Self::SPANS_APPSEC_SAMPLING_PROCESSOR,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_retention_filter_type.rs b/src/datadogV2/model/model_retention_filter_type.rs
index a9d30b8fe..7fd6346f2 100644
--- a/src/datadogV2/model/model_retention_filter_type.rs
+++ b/src/datadogV2/model/model_retention_filter_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum RetentionFilterType {
-    #[serde(rename = "spans-sampling-processor")]
     SPANS_SAMPLING_PROCESSOR,
 }
 
@@ -18,3 +17,32 @@ impl ToString for RetentionFilterType {
         }
     }
 }
+
+impl Serialize for RetentionFilterType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for RetentionFilterType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "spans-sampling-processor" => Self::SPANS_SAMPLING_PROCESSOR,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_roles_sort.rs b/src/datadogV2/model/model_roles_sort.rs
index 236fffc7c..a5c55c486 100644
--- a/src/datadogV2/model/model_roles_sort.rs
+++ b/src/datadogV2/model/model_roles_sort.rs
@@ -2,22 +2,16 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum RolesSort {
-    #[serde(rename = "name")]
     NAME_ASCENDING,
-    #[serde(rename = "-name")]
     NAME_DESCENDING,
-    #[serde(rename = "modified_at")]
     MODIFIED_AT_ASCENDING,
-    #[serde(rename = "-modified_at")]
     MODIFIED_AT_DESCENDING,
-    #[serde(rename = "user_count")]
     USER_COUNT_ASCENDING,
-    #[serde(rename = "-user_count")]
     USER_COUNT_DESCENDING,
 }
 
@@ -33,3 +27,37 @@ impl ToString for RolesSort {
         }
     }
 }
+
+impl Serialize for RolesSort {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for RolesSort {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "name" => Self::NAME_ASCENDING,
+            "-name" => Self::NAME_DESCENDING,
+            "modified_at" => Self::MODIFIED_AT_ASCENDING,
+            "-modified_at" => Self::MODIFIED_AT_DESCENDING,
+            "user_count" => Self::USER_COUNT_ASCENDING,
+            "-user_count" => Self::USER_COUNT_DESCENDING,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_roles_type.rs b/src/datadogV2/model/model_roles_type.rs
index 5478c4dcd..27cddc779 100644
--- a/src/datadogV2/model/model_roles_type.rs
+++ b/src/datadogV2/model/model_roles_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum RolesType {
-    #[serde(rename = "roles")]
     ROLES,
 }
 
@@ -18,3 +17,32 @@ impl ToString for RolesType {
         }
     }
 }
+
+impl Serialize for RolesType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for RolesType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "roles" => Self::ROLES,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_rule_type.rs b/src/datadogV2/model/model_rule_type.rs
index 48318abe2..cff3d153a 100644
--- a/src/datadogV2/model/model_rule_type.rs
+++ b/src/datadogV2/model/model_rule_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum RuleType {
-    #[serde(rename = "rule")]
     RULE,
 }
 
@@ -18,3 +17,32 @@ impl ToString for RuleType {
         }
     }
 }
+
+impl Serialize for RuleType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for RuleType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "rule" => Self::RULE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_rum_aggregate_sort_type.rs b/src/datadogV2/model/model_rum_aggregate_sort_type.rs
index 98420ebc7..c6129565b 100644
--- a/src/datadogV2/model/model_rum_aggregate_sort_type.rs
+++ b/src/datadogV2/model/model_rum_aggregate_sort_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum RUMAggregateSortType {
-    #[serde(rename = "alphabetical")]
     ALPHABETICAL,
-    #[serde(rename = "measure")]
     MEASURE,
 }
 
@@ -21,3 +19,33 @@ impl ToString for RUMAggregateSortType {
         }
     }
 }
+
+impl Serialize for RUMAggregateSortType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for RUMAggregateSortType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "alphabetical" => Self::ALPHABETICAL,
+            "measure" => Self::MEASURE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_rum_aggregation_function.rs b/src/datadogV2/model/model_rum_aggregation_function.rs
index ed4182dc9..278843c34 100644
--- a/src/datadogV2/model/model_rum_aggregation_function.rs
+++ b/src/datadogV2/model/model_rum_aggregation_function.rs
@@ -2,34 +2,22 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum RUMAggregationFunction {
-    #[serde(rename = "count")]
     COUNT,
-    #[serde(rename = "cardinality")]
     CARDINALITY,
-    #[serde(rename = "pc75")]
     PERCENTILE_75,
-    #[serde(rename = "pc90")]
     PERCENTILE_90,
-    #[serde(rename = "pc95")]
     PERCENTILE_95,
-    #[serde(rename = "pc98")]
     PERCENTILE_98,
-    #[serde(rename = "pc99")]
     PERCENTILE_99,
-    #[serde(rename = "sum")]
     SUM,
-    #[serde(rename = "min")]
     MIN,
-    #[serde(rename = "max")]
     MAX,
-    #[serde(rename = "avg")]
     AVG,
-    #[serde(rename = "median")]
     MEDIAN,
 }
 
@@ -51,3 +39,43 @@ impl ToString for RUMAggregationFunction {
         }
     }
 }
+
+impl Serialize for RUMAggregationFunction {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for RUMAggregationFunction {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "count" => Self::COUNT,
+            "cardinality" => Self::CARDINALITY,
+            "pc75" => Self::PERCENTILE_75,
+            "pc90" => Self::PERCENTILE_90,
+            "pc95" => Self::PERCENTILE_95,
+            "pc98" => Self::PERCENTILE_98,
+            "pc99" => Self::PERCENTILE_99,
+            "sum" => Self::SUM,
+            "min" => Self::MIN,
+            "max" => Self::MAX,
+            "avg" => Self::AVG,
+            "median" => Self::MEDIAN,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_rum_application_create_type.rs b/src/datadogV2/model/model_rum_application_create_type.rs
index cc04bf555..8f2a7a383 100644
--- a/src/datadogV2/model/model_rum_application_create_type.rs
+++ b/src/datadogV2/model/model_rum_application_create_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum RUMApplicationCreateType {
-    #[serde(rename = "rum_application_create")]
     RUM_APPLICATION_CREATE,
 }
 
@@ -18,3 +17,32 @@ impl ToString for RUMApplicationCreateType {
         }
     }
 }
+
+impl Serialize for RUMApplicationCreateType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for RUMApplicationCreateType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "rum_application_create" => Self::RUM_APPLICATION_CREATE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_rum_application_list_type.rs b/src/datadogV2/model/model_rum_application_list_type.rs
index 4c585ef2f..56f26fde7 100644
--- a/src/datadogV2/model/model_rum_application_list_type.rs
+++ b/src/datadogV2/model/model_rum_application_list_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum RUMApplicationListType {
-    #[serde(rename = "rum_application")]
     RUM_APPLICATION,
 }
 
@@ -18,3 +17,32 @@ impl ToString for RUMApplicationListType {
         }
     }
 }
+
+impl Serialize for RUMApplicationListType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for RUMApplicationListType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "rum_application" => Self::RUM_APPLICATION,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_rum_application_type.rs b/src/datadogV2/model/model_rum_application_type.rs
index 00f2c2b28..8ab4bdddc 100644
--- a/src/datadogV2/model/model_rum_application_type.rs
+++ b/src/datadogV2/model/model_rum_application_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum RUMApplicationType {
-    #[serde(rename = "rum_application")]
     RUM_APPLICATION,
 }
 
@@ -18,3 +17,32 @@ impl ToString for RUMApplicationType {
         }
     }
 }
+
+impl Serialize for RUMApplicationType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for RUMApplicationType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "rum_application" => Self::RUM_APPLICATION,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_rum_application_update_type.rs b/src/datadogV2/model/model_rum_application_update_type.rs
index 8b215b373..9cb064b73 100644
--- a/src/datadogV2/model/model_rum_application_update_type.rs
+++ b/src/datadogV2/model/model_rum_application_update_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum RUMApplicationUpdateType {
-    #[serde(rename = "rum_application_update")]
     RUM_APPLICATION_UPDATE,
 }
 
@@ -18,3 +17,32 @@ impl ToString for RUMApplicationUpdateType {
         }
     }
 }
+
+impl Serialize for RUMApplicationUpdateType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for RUMApplicationUpdateType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "rum_application_update" => Self::RUM_APPLICATION_UPDATE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_rum_compute_type.rs b/src/datadogV2/model/model_rum_compute_type.rs
index f21c9f15e..2e7c0c706 100644
--- a/src/datadogV2/model/model_rum_compute_type.rs
+++ b/src/datadogV2/model/model_rum_compute_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum RUMComputeType {
-    #[serde(rename = "timeseries")]
     TIMESERIES,
-    #[serde(rename = "total")]
     TOTAL,
 }
 
@@ -21,3 +19,33 @@ impl ToString for RUMComputeType {
         }
     }
 }
+
+impl Serialize for RUMComputeType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for RUMComputeType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "timeseries" => Self::TIMESERIES,
+            "total" => Self::TOTAL,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_rum_event_type.rs b/src/datadogV2/model/model_rum_event_type.rs
index 65b1e2189..ec4491cdb 100644
--- a/src/datadogV2/model/model_rum_event_type.rs
+++ b/src/datadogV2/model/model_rum_event_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum RUMEventType {
-    #[serde(rename = "rum")]
     RUM,
 }
 
@@ -18,3 +17,32 @@ impl ToString for RUMEventType {
         }
     }
 }
+
+impl Serialize for RUMEventType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for RUMEventType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "rum" => Self::RUM,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_rum_response_status.rs b/src/datadogV2/model/model_rum_response_status.rs
index edeb1e78e..751c7f7a3 100644
--- a/src/datadogV2/model/model_rum_response_status.rs
+++ b/src/datadogV2/model/model_rum_response_status.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum RUMResponseStatus {
-    #[serde(rename = "done")]
     DONE,
-    #[serde(rename = "timeout")]
     TIMEOUT,
 }
 
@@ -21,3 +19,33 @@ impl ToString for RUMResponseStatus {
         }
     }
 }
+
+impl Serialize for RUMResponseStatus {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for RUMResponseStatus {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "done" => Self::DONE,
+            "timeout" => Self::TIMEOUT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_rum_sort.rs b/src/datadogV2/model/model_rum_sort.rs
index bfc74ede3..78be1ac7d 100644
--- a/src/datadogV2/model/model_rum_sort.rs
+++ b/src/datadogV2/model/model_rum_sort.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum RUMSort {
-    #[serde(rename = "timestamp")]
     TIMESTAMP_ASCENDING,
-    #[serde(rename = "-timestamp")]
     TIMESTAMP_DESCENDING,
 }
 
@@ -21,3 +19,33 @@ impl ToString for RUMSort {
         }
     }
 }
+
+impl Serialize for RUMSort {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for RUMSort {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "timestamp" => Self::TIMESTAMP_ASCENDING,
+            "-timestamp" => Self::TIMESTAMP_DESCENDING,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_rum_sort_order.rs b/src/datadogV2/model/model_rum_sort_order.rs
index 2d108215c..db39990f6 100644
--- a/src/datadogV2/model/model_rum_sort_order.rs
+++ b/src/datadogV2/model/model_rum_sort_order.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum RUMSortOrder {
-    #[serde(rename = "asc")]
     ASCENDING,
-    #[serde(rename = "desc")]
     DESCENDING,
 }
 
@@ -21,3 +19,33 @@ impl ToString for RUMSortOrder {
         }
     }
 }
+
+impl Serialize for RUMSortOrder {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for RUMSortOrder {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "asc" => Self::ASCENDING,
+            "desc" => Self::DESCENDING,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_saml_assertion_attributes_type.rs b/src/datadogV2/model/model_saml_assertion_attributes_type.rs
index dac3a8594..b58d21499 100644
--- a/src/datadogV2/model/model_saml_assertion_attributes_type.rs
+++ b/src/datadogV2/model/model_saml_assertion_attributes_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SAMLAssertionAttributesType {
-    #[serde(rename = "saml_assertion_attributes")]
     SAML_ASSERTION_ATTRIBUTES,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SAMLAssertionAttributesType {
         }
     }
 }
+
+impl Serialize for SAMLAssertionAttributesType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SAMLAssertionAttributesType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "saml_assertion_attributes" => Self::SAML_ASSERTION_ATTRIBUTES,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_scalar_column_type_group.rs b/src/datadogV2/model/model_scalar_column_type_group.rs
index e77a16fd8..cdc232df1 100644
--- a/src/datadogV2/model/model_scalar_column_type_group.rs
+++ b/src/datadogV2/model/model_scalar_column_type_group.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ScalarColumnTypeGroup {
-    #[serde(rename = "group")]
     GROUP,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ScalarColumnTypeGroup {
         }
     }
 }
+
+impl Serialize for ScalarColumnTypeGroup {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ScalarColumnTypeGroup {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "group" => Self::GROUP,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_scalar_column_type_number.rs b/src/datadogV2/model/model_scalar_column_type_number.rs
index b9710feba..2d491841e 100644
--- a/src/datadogV2/model/model_scalar_column_type_number.rs
+++ b/src/datadogV2/model/model_scalar_column_type_number.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ScalarColumnTypeNumber {
-    #[serde(rename = "number")]
     NUMBER,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ScalarColumnTypeNumber {
         }
     }
 }
+
+impl Serialize for ScalarColumnTypeNumber {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ScalarColumnTypeNumber {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "number" => Self::NUMBER,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_scalar_formula_request_type.rs b/src/datadogV2/model/model_scalar_formula_request_type.rs
index ce2422e52..d71afa867 100644
--- a/src/datadogV2/model/model_scalar_formula_request_type.rs
+++ b/src/datadogV2/model/model_scalar_formula_request_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ScalarFormulaRequestType {
-    #[serde(rename = "scalar_request")]
     SCALAR_REQUEST,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ScalarFormulaRequestType {
         }
     }
 }
+
+impl Serialize for ScalarFormulaRequestType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ScalarFormulaRequestType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "scalar_request" => Self::SCALAR_REQUEST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_scalar_formula_response_type.rs b/src/datadogV2/model/model_scalar_formula_response_type.rs
index 9e263b996..8d18b0546 100644
--- a/src/datadogV2/model/model_scalar_formula_response_type.rs
+++ b/src/datadogV2/model/model_scalar_formula_response_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ScalarFormulaResponseType {
-    #[serde(rename = "scalar_response")]
     SCALAR_RESPONSE,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ScalarFormulaResponseType {
         }
     }
 }
+
+impl Serialize for ScalarFormulaResponseType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ScalarFormulaResponseType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "scalar_response" => Self::SCALAR_RESPONSE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_scorecard_type.rs b/src/datadogV2/model/model_scorecard_type.rs
index 67073b69d..5e83d8d4e 100644
--- a/src/datadogV2/model/model_scorecard_type.rs
+++ b/src/datadogV2/model/model_scorecard_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ScorecardType {
-    #[serde(rename = "scorecard")]
     SCORECARD,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ScorecardType {
         }
     }
 }
+
+impl Serialize for ScorecardType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ScorecardType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "scorecard" => Self::SCORECARD,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_security_filter_filtered_data_type.rs b/src/datadogV2/model/model_security_filter_filtered_data_type.rs
index 873760567..8c85d14a9 100644
--- a/src/datadogV2/model/model_security_filter_filtered_data_type.rs
+++ b/src/datadogV2/model/model_security_filter_filtered_data_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SecurityFilterFilteredDataType {
-    #[serde(rename = "logs")]
     LOGS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SecurityFilterFilteredDataType {
         }
     }
 }
+
+impl Serialize for SecurityFilterFilteredDataType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SecurityFilterFilteredDataType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "logs" => Self::LOGS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_security_filter_type.rs b/src/datadogV2/model/model_security_filter_type.rs
index bf66c70a1..ac6a65cad 100644
--- a/src/datadogV2/model/model_security_filter_type.rs
+++ b/src/datadogV2/model/model_security_filter_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SecurityFilterType {
-    #[serde(rename = "security_filters")]
     SECURITY_FILTERS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SecurityFilterType {
         }
     }
 }
+
+impl Serialize for SecurityFilterType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SecurityFilterType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "security_filters" => Self::SECURITY_FILTERS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_security_monitoring_filter_action.rs b/src/datadogV2/model/model_security_monitoring_filter_action.rs
index 560f1c0dd..4314a9bba 100644
--- a/src/datadogV2/model/model_security_monitoring_filter_action.rs
+++ b/src/datadogV2/model/model_security_monitoring_filter_action.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SecurityMonitoringFilterAction {
-    #[serde(rename = "require")]
     REQUIRE,
-    #[serde(rename = "suppress")]
     SUPPRESS,
 }
 
@@ -21,3 +19,33 @@ impl ToString for SecurityMonitoringFilterAction {
         }
     }
 }
+
+impl Serialize for SecurityMonitoringFilterAction {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SecurityMonitoringFilterAction {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "require" => Self::REQUIRE,
+            "suppress" => Self::SUPPRESS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_security_monitoring_rule_detection_method.rs b/src/datadogV2/model/model_security_monitoring_rule_detection_method.rs
index 34947cee0..21034b9fd 100644
--- a/src/datadogV2/model/model_security_monitoring_rule_detection_method.rs
+++ b/src/datadogV2/model/model_security_monitoring_rule_detection_method.rs
@@ -2,22 +2,16 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SecurityMonitoringRuleDetectionMethod {
-    #[serde(rename = "threshold")]
     THRESHOLD,
-    #[serde(rename = "new_value")]
     NEW_VALUE,
-    #[serde(rename = "anomaly_detection")]
     ANOMALY_DETECTION,
-    #[serde(rename = "impossible_travel")]
     IMPOSSIBLE_TRAVEL,
-    #[serde(rename = "hardcoded")]
     HARDCODED,
-    #[serde(rename = "third_party")]
     THIRD_PARTY,
 }
 
@@ -33,3 +27,37 @@ impl ToString for SecurityMonitoringRuleDetectionMethod {
         }
     }
 }
+
+impl Serialize for SecurityMonitoringRuleDetectionMethod {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SecurityMonitoringRuleDetectionMethod {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "threshold" => Self::THRESHOLD,
+            "new_value" => Self::NEW_VALUE,
+            "anomaly_detection" => Self::ANOMALY_DETECTION,
+            "impossible_travel" => Self::IMPOSSIBLE_TRAVEL,
+            "hardcoded" => Self::HARDCODED,
+            "third_party" => Self::THIRD_PARTY,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_security_monitoring_rule_evaluation_window.rs b/src/datadogV2/model/model_security_monitoring_rule_evaluation_window.rs
index cafe043ae..b0f23387a 100644
--- a/src/datadogV2/model/model_security_monitoring_rule_evaluation_window.rs
+++ b/src/datadogV2/model/model_security_monitoring_rule_evaluation_window.rs
@@ -2,35 +2,60 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde_repr::{Deserialize_repr, Serialize_repr};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(
-    Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize_repr, Deserialize_repr,
-)]
-#[repr(i32)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SecurityMonitoringRuleEvaluationWindow {
-    ZERO_MINUTES = 0,
-    ONE_MINUTE = 60,
-    FIVE_MINUTES = 300,
-    TEN_MINUTES = 600,
-    FIFTEEN_MINUTES = 900,
-    THIRTY_MINUTES = 1800,
-    ONE_HOUR = 3600,
-    TWO_HOURS = 7200,
+    ZERO_MINUTES,
+    ONE_MINUTE,
+    FIVE_MINUTES,
+    TEN_MINUTES,
+    FIFTEEN_MINUTES,
+    THIRTY_MINUTES,
+    ONE_HOUR,
+    TWO_HOURS,
 }
 
-impl ToString for SecurityMonitoringRuleEvaluationWindow {
-    fn to_string(&self) -> String {
+impl Serialize for SecurityMonitoringRuleEvaluationWindow {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
         match self {
-            Self::ZERO_MINUTES => String::from("0"),
-            Self::ONE_MINUTE => String::from("60"),
-            Self::FIVE_MINUTES => String::from("300"),
-            Self::TEN_MINUTES => String::from("600"),
-            Self::FIFTEEN_MINUTES => String::from("900"),
-            Self::THIRTY_MINUTES => String::from("1800"),
-            Self::ONE_HOUR => String::from("3600"),
-            Self::TWO_HOURS => String::from("7200"),
+            Self::ZERO_MINUTES => serializer.serialize_i32(0),
+            Self::ONE_MINUTE => serializer.serialize_i32(60),
+            Self::FIVE_MINUTES => serializer.serialize_i32(300),
+            Self::TEN_MINUTES => serializer.serialize_i32(600),
+            Self::FIFTEEN_MINUTES => serializer.serialize_i32(900),
+            Self::THIRTY_MINUTES => serializer.serialize_i32(1800),
+            Self::ONE_HOUR => serializer.serialize_i32(3600),
+            Self::TWO_HOURS => serializer.serialize_i32(7200),
         }
     }
 }
+
+impl<'de> Deserialize<'de> for SecurityMonitoringRuleEvaluationWindow {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: i32 = i32::deserialize(deserializer)?;
+        Ok(match s {
+            0 => Self::ZERO_MINUTES,
+            60 => Self::ONE_MINUTE,
+            300 => Self::FIVE_MINUTES,
+            600 => Self::TEN_MINUTES,
+            900 => Self::FIFTEEN_MINUTES,
+            1800 => Self::THIRTY_MINUTES,
+            3600 => Self::ONE_HOUR,
+            7200 => Self::TWO_HOURS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_security_monitoring_rule_hardcoded_evaluator_type.rs b/src/datadogV2/model/model_security_monitoring_rule_hardcoded_evaluator_type.rs
index 220c21815..b3811c0a9 100644
--- a/src/datadogV2/model/model_security_monitoring_rule_hardcoded_evaluator_type.rs
+++ b/src/datadogV2/model/model_security_monitoring_rule_hardcoded_evaluator_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SecurityMonitoringRuleHardcodedEvaluatorType {
-    #[serde(rename = "log4shell")]
     LOG4SHELL,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SecurityMonitoringRuleHardcodedEvaluatorType {
         }
     }
 }
+
+impl Serialize for SecurityMonitoringRuleHardcodedEvaluatorType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SecurityMonitoringRuleHardcodedEvaluatorType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "log4shell" => Self::LOG4SHELL,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_security_monitoring_rule_keep_alive.rs b/src/datadogV2/model/model_security_monitoring_rule_keep_alive.rs
index 877388e4f..e4bb89ce2 100644
--- a/src/datadogV2/model/model_security_monitoring_rule_keep_alive.rs
+++ b/src/datadogV2/model/model_security_monitoring_rule_keep_alive.rs
@@ -2,39 +2,66 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde_repr::{Deserialize_repr, Serialize_repr};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(
-    Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize_repr, Deserialize_repr,
-)]
-#[repr(i32)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SecurityMonitoringRuleKeepAlive {
-    ZERO_MINUTES = 0,
-    ONE_MINUTE = 60,
-    FIVE_MINUTES = 300,
-    TEN_MINUTES = 600,
-    FIFTEEN_MINUTES = 900,
-    THIRTY_MINUTES = 1800,
-    ONE_HOUR = 3600,
-    TWO_HOURS = 7200,
-    THREE_HOURS = 10800,
-    SIX_HOURS = 21600,
+    ZERO_MINUTES,
+    ONE_MINUTE,
+    FIVE_MINUTES,
+    TEN_MINUTES,
+    FIFTEEN_MINUTES,
+    THIRTY_MINUTES,
+    ONE_HOUR,
+    TWO_HOURS,
+    THREE_HOURS,
+    SIX_HOURS,
 }
 
-impl ToString for SecurityMonitoringRuleKeepAlive {
-    fn to_string(&self) -> String {
+impl Serialize for SecurityMonitoringRuleKeepAlive {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
         match self {
-            Self::ZERO_MINUTES => String::from("0"),
-            Self::ONE_MINUTE => String::from("60"),
-            Self::FIVE_MINUTES => String::from("300"),
-            Self::TEN_MINUTES => String::from("600"),
-            Self::FIFTEEN_MINUTES => String::from("900"),
-            Self::THIRTY_MINUTES => String::from("1800"),
-            Self::ONE_HOUR => String::from("3600"),
-            Self::TWO_HOURS => String::from("7200"),
-            Self::THREE_HOURS => String::from("10800"),
-            Self::SIX_HOURS => String::from("21600"),
+            Self::ZERO_MINUTES => serializer.serialize_i32(0),
+            Self::ONE_MINUTE => serializer.serialize_i32(60),
+            Self::FIVE_MINUTES => serializer.serialize_i32(300),
+            Self::TEN_MINUTES => serializer.serialize_i32(600),
+            Self::FIFTEEN_MINUTES => serializer.serialize_i32(900),
+            Self::THIRTY_MINUTES => serializer.serialize_i32(1800),
+            Self::ONE_HOUR => serializer.serialize_i32(3600),
+            Self::TWO_HOURS => serializer.serialize_i32(7200),
+            Self::THREE_HOURS => serializer.serialize_i32(10800),
+            Self::SIX_HOURS => serializer.serialize_i32(21600),
         }
     }
 }
+
+impl<'de> Deserialize<'de> for SecurityMonitoringRuleKeepAlive {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: i32 = i32::deserialize(deserializer)?;
+        Ok(match s {
+            0 => Self::ZERO_MINUTES,
+            60 => Self::ONE_MINUTE,
+            300 => Self::FIVE_MINUTES,
+            600 => Self::TEN_MINUTES,
+            900 => Self::FIFTEEN_MINUTES,
+            1800 => Self::THIRTY_MINUTES,
+            3600 => Self::ONE_HOUR,
+            7200 => Self::TWO_HOURS,
+            10800 => Self::THREE_HOURS,
+            21600 => Self::SIX_HOURS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_security_monitoring_rule_max_signal_duration.rs b/src/datadogV2/model/model_security_monitoring_rule_max_signal_duration.rs
index f72f899e1..589eb44da 100644
--- a/src/datadogV2/model/model_security_monitoring_rule_max_signal_duration.rs
+++ b/src/datadogV2/model/model_security_monitoring_rule_max_signal_duration.rs
@@ -2,43 +2,72 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde_repr::{Deserialize_repr, Serialize_repr};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(
-    Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize_repr, Deserialize_repr,
-)]
-#[repr(i32)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SecurityMonitoringRuleMaxSignalDuration {
-    ZERO_MINUTES = 0,
-    ONE_MINUTE = 60,
-    FIVE_MINUTES = 300,
-    TEN_MINUTES = 600,
-    FIFTEEN_MINUTES = 900,
-    THIRTY_MINUTES = 1800,
-    ONE_HOUR = 3600,
-    TWO_HOURS = 7200,
-    THREE_HOURS = 10800,
-    SIX_HOURS = 21600,
-    TWELVE_HOURS = 43200,
-    ONE_DAY = 86400,
+    ZERO_MINUTES,
+    ONE_MINUTE,
+    FIVE_MINUTES,
+    TEN_MINUTES,
+    FIFTEEN_MINUTES,
+    THIRTY_MINUTES,
+    ONE_HOUR,
+    TWO_HOURS,
+    THREE_HOURS,
+    SIX_HOURS,
+    TWELVE_HOURS,
+    ONE_DAY,
 }
 
-impl ToString for SecurityMonitoringRuleMaxSignalDuration {
-    fn to_string(&self) -> String {
+impl Serialize for SecurityMonitoringRuleMaxSignalDuration {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
         match self {
-            Self::ZERO_MINUTES => String::from("0"),
-            Self::ONE_MINUTE => String::from("60"),
-            Self::FIVE_MINUTES => String::from("300"),
-            Self::TEN_MINUTES => String::from("600"),
-            Self::FIFTEEN_MINUTES => String::from("900"),
-            Self::THIRTY_MINUTES => String::from("1800"),
-            Self::ONE_HOUR => String::from("3600"),
-            Self::TWO_HOURS => String::from("7200"),
-            Self::THREE_HOURS => String::from("10800"),
-            Self::SIX_HOURS => String::from("21600"),
-            Self::TWELVE_HOURS => String::from("43200"),
-            Self::ONE_DAY => String::from("86400"),
+            Self::ZERO_MINUTES => serializer.serialize_i32(0),
+            Self::ONE_MINUTE => serializer.serialize_i32(60),
+            Self::FIVE_MINUTES => serializer.serialize_i32(300),
+            Self::TEN_MINUTES => serializer.serialize_i32(600),
+            Self::FIFTEEN_MINUTES => serializer.serialize_i32(900),
+            Self::THIRTY_MINUTES => serializer.serialize_i32(1800),
+            Self::ONE_HOUR => serializer.serialize_i32(3600),
+            Self::TWO_HOURS => serializer.serialize_i32(7200),
+            Self::THREE_HOURS => serializer.serialize_i32(10800),
+            Self::SIX_HOURS => serializer.serialize_i32(21600),
+            Self::TWELVE_HOURS => serializer.serialize_i32(43200),
+            Self::ONE_DAY => serializer.serialize_i32(86400),
         }
     }
 }
+
+impl<'de> Deserialize<'de> for SecurityMonitoringRuleMaxSignalDuration {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: i32 = i32::deserialize(deserializer)?;
+        Ok(match s {
+            0 => Self::ZERO_MINUTES,
+            60 => Self::ONE_MINUTE,
+            300 => Self::FIVE_MINUTES,
+            600 => Self::TEN_MINUTES,
+            900 => Self::FIFTEEN_MINUTES,
+            1800 => Self::THIRTY_MINUTES,
+            3600 => Self::ONE_HOUR,
+            7200 => Self::TWO_HOURS,
+            10800 => Self::THREE_HOURS,
+            21600 => Self::SIX_HOURS,
+            43200 => Self::TWELVE_HOURS,
+            86400 => Self::ONE_DAY,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_security_monitoring_rule_new_value_options_forget_after.rs b/src/datadogV2/model/model_security_monitoring_rule_new_value_options_forget_after.rs
index 55bf89a3b..1c544e29d 100644
--- a/src/datadogV2/model/model_security_monitoring_rule_new_value_options_forget_after.rs
+++ b/src/datadogV2/model/model_security_monitoring_rule_new_value_options_forget_after.rs
@@ -2,31 +2,54 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde_repr::{Deserialize_repr, Serialize_repr};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(
-    Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize_repr, Deserialize_repr,
-)]
-#[repr(i32)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SecurityMonitoringRuleNewValueOptionsForgetAfter {
-    ONE_DAY = 1,
-    TWO_DAYS = 2,
-    ONE_WEEK = 7,
-    TWO_WEEKS = 14,
-    THREE_WEEKS = 21,
-    FOUR_WEEKS = 28,
+    ONE_DAY,
+    TWO_DAYS,
+    ONE_WEEK,
+    TWO_WEEKS,
+    THREE_WEEKS,
+    FOUR_WEEKS,
 }
 
-impl ToString for SecurityMonitoringRuleNewValueOptionsForgetAfter {
-    fn to_string(&self) -> String {
+impl Serialize for SecurityMonitoringRuleNewValueOptionsForgetAfter {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
         match self {
-            Self::ONE_DAY => String::from("1"),
-            Self::TWO_DAYS => String::from("2"),
-            Self::ONE_WEEK => String::from("7"),
-            Self::TWO_WEEKS => String::from("14"),
-            Self::THREE_WEEKS => String::from("21"),
-            Self::FOUR_WEEKS => String::from("28"),
+            Self::ONE_DAY => serializer.serialize_i32(1),
+            Self::TWO_DAYS => serializer.serialize_i32(2),
+            Self::ONE_WEEK => serializer.serialize_i32(7),
+            Self::TWO_WEEKS => serializer.serialize_i32(14),
+            Self::THREE_WEEKS => serializer.serialize_i32(21),
+            Self::FOUR_WEEKS => serializer.serialize_i32(28),
         }
     }
 }
+
+impl<'de> Deserialize<'de> for SecurityMonitoringRuleNewValueOptionsForgetAfter {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: i32 = i32::deserialize(deserializer)?;
+        Ok(match s {
+            1 => Self::ONE_DAY,
+            2 => Self::TWO_DAYS,
+            7 => Self::ONE_WEEK,
+            14 => Self::TWO_WEEKS,
+            21 => Self::THREE_WEEKS,
+            28 => Self::FOUR_WEEKS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_security_monitoring_rule_new_value_options_learning_duration.rs b/src/datadogV2/model/model_security_monitoring_rule_new_value_options_learning_duration.rs
index 317fb7d93..b83f34d2d 100644
--- a/src/datadogV2/model/model_security_monitoring_rule_new_value_options_learning_duration.rs
+++ b/src/datadogV2/model/model_security_monitoring_rule_new_value_options_learning_duration.rs
@@ -2,25 +2,45 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde_repr::{Deserialize_repr, Serialize_repr};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(
-    Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize_repr, Deserialize_repr,
-)]
-#[repr(i32)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SecurityMonitoringRuleNewValueOptionsLearningDuration {
-    ZERO_DAYS = 0,
-    ONE_DAY = 1,
-    SEVEN_DAYS = 7,
+    ZERO_DAYS,
+    ONE_DAY,
+    SEVEN_DAYS,
 }
 
-impl ToString for SecurityMonitoringRuleNewValueOptionsLearningDuration {
-    fn to_string(&self) -> String {
+impl Serialize for SecurityMonitoringRuleNewValueOptionsLearningDuration {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
         match self {
-            Self::ZERO_DAYS => String::from("0"),
-            Self::ONE_DAY => String::from("1"),
-            Self::SEVEN_DAYS => String::from("7"),
+            Self::ZERO_DAYS => serializer.serialize_i32(0),
+            Self::ONE_DAY => serializer.serialize_i32(1),
+            Self::SEVEN_DAYS => serializer.serialize_i32(7),
         }
     }
 }
+
+impl<'de> Deserialize<'de> for SecurityMonitoringRuleNewValueOptionsLearningDuration {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: i32 = i32::deserialize(deserializer)?;
+        Ok(match s {
+            0 => Self::ZERO_DAYS,
+            1 => Self::ONE_DAY,
+            7 => Self::SEVEN_DAYS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_security_monitoring_rule_new_value_options_learning_method.rs b/src/datadogV2/model/model_security_monitoring_rule_new_value_options_learning_method.rs
index c1ed8eb30..7dc4f97a2 100644
--- a/src/datadogV2/model/model_security_monitoring_rule_new_value_options_learning_method.rs
+++ b/src/datadogV2/model/model_security_monitoring_rule_new_value_options_learning_method.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SecurityMonitoringRuleNewValueOptionsLearningMethod {
-    #[serde(rename = "duration")]
     DURATION,
-    #[serde(rename = "threshold")]
     THRESHOLD,
 }
 
@@ -21,3 +19,33 @@ impl ToString for SecurityMonitoringRuleNewValueOptionsLearningMethod {
         }
     }
 }
+
+impl Serialize for SecurityMonitoringRuleNewValueOptionsLearningMethod {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SecurityMonitoringRuleNewValueOptionsLearningMethod {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "duration" => Self::DURATION,
+            "threshold" => Self::THRESHOLD,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_security_monitoring_rule_new_value_options_learning_threshold.rs b/src/datadogV2/model/model_security_monitoring_rule_new_value_options_learning_threshold.rs
index 994f90595..22a68f1d2 100644
--- a/src/datadogV2/model/model_security_monitoring_rule_new_value_options_learning_threshold.rs
+++ b/src/datadogV2/model/model_security_monitoring_rule_new_value_options_learning_threshold.rs
@@ -2,23 +2,42 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde_repr::{Deserialize_repr, Serialize_repr};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(
-    Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize_repr, Deserialize_repr,
-)]
-#[repr(i32)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SecurityMonitoringRuleNewValueOptionsLearningThreshold {
-    ZERO_OCCURRENCES = 0,
-    ONE_OCCURRENCE = 1,
+    ZERO_OCCURRENCES,
+    ONE_OCCURRENCE,
 }
 
-impl ToString for SecurityMonitoringRuleNewValueOptionsLearningThreshold {
-    fn to_string(&self) -> String {
+impl Serialize for SecurityMonitoringRuleNewValueOptionsLearningThreshold {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
         match self {
-            Self::ZERO_OCCURRENCES => String::from("0"),
-            Self::ONE_OCCURRENCE => String::from("1"),
+            Self::ZERO_OCCURRENCES => serializer.serialize_i32(0),
+            Self::ONE_OCCURRENCE => serializer.serialize_i32(1),
         }
     }
 }
+
+impl<'de> Deserialize<'de> for SecurityMonitoringRuleNewValueOptionsLearningThreshold {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: i32 = i32::deserialize(deserializer)?;
+        Ok(match s {
+            0 => Self::ZERO_OCCURRENCES,
+            1 => Self::ONE_OCCURRENCE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_security_monitoring_rule_query_aggregation.rs b/src/datadogV2/model/model_security_monitoring_rule_query_aggregation.rs
index 2b1ca6486..d2a045deb 100644
--- a/src/datadogV2/model/model_security_monitoring_rule_query_aggregation.rs
+++ b/src/datadogV2/model/model_security_monitoring_rule_query_aggregation.rs
@@ -2,26 +2,18 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SecurityMonitoringRuleQueryAggregation {
-    #[serde(rename = "count")]
     COUNT,
-    #[serde(rename = "cardinality")]
     CARDINALITY,
-    #[serde(rename = "sum")]
     SUM,
-    #[serde(rename = "max")]
     MAX,
-    #[serde(rename = "new_value")]
     NEW_VALUE,
-    #[serde(rename = "geo_data")]
     GEO_DATA,
-    #[serde(rename = "event_count")]
     EVENT_COUNT,
-    #[serde(rename = "none")]
     NONE,
 }
 
@@ -39,3 +31,39 @@ impl ToString for SecurityMonitoringRuleQueryAggregation {
         }
     }
 }
+
+impl Serialize for SecurityMonitoringRuleQueryAggregation {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SecurityMonitoringRuleQueryAggregation {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "count" => Self::COUNT,
+            "cardinality" => Self::CARDINALITY,
+            "sum" => Self::SUM,
+            "max" => Self::MAX,
+            "new_value" => Self::NEW_VALUE,
+            "geo_data" => Self::GEO_DATA,
+            "event_count" => Self::EVENT_COUNT,
+            "none" => Self::NONE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_security_monitoring_rule_severity.rs b/src/datadogV2/model/model_security_monitoring_rule_severity.rs
index f8a28c069..83700caa7 100644
--- a/src/datadogV2/model/model_security_monitoring_rule_severity.rs
+++ b/src/datadogV2/model/model_security_monitoring_rule_severity.rs
@@ -2,20 +2,15 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SecurityMonitoringRuleSeverity {
-    #[serde(rename = "info")]
     INFO,
-    #[serde(rename = "low")]
     LOW,
-    #[serde(rename = "medium")]
     MEDIUM,
-    #[serde(rename = "high")]
     HIGH,
-    #[serde(rename = "critical")]
     CRITICAL,
 }
 
@@ -30,3 +25,36 @@ impl ToString for SecurityMonitoringRuleSeverity {
         }
     }
 }
+
+impl Serialize for SecurityMonitoringRuleSeverity {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SecurityMonitoringRuleSeverity {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "info" => Self::INFO,
+            "low" => Self::LOW,
+            "medium" => Self::MEDIUM,
+            "high" => Self::HIGH,
+            "critical" => Self::CRITICAL,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_security_monitoring_rule_type_create.rs b/src/datadogV2/model/model_security_monitoring_rule_type_create.rs
index 57dbb8996..525ef03c7 100644
--- a/src/datadogV2/model/model_security_monitoring_rule_type_create.rs
+++ b/src/datadogV2/model/model_security_monitoring_rule_type_create.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SecurityMonitoringRuleTypeCreate {
-    #[serde(rename = "application_security")]
     APPLICATION_SECURITY,
-    #[serde(rename = "log_detection")]
     LOG_DETECTION,
-    #[serde(rename = "workload_security")]
     WORKLOAD_SECURITY,
 }
 
@@ -24,3 +21,34 @@ impl ToString for SecurityMonitoringRuleTypeCreate {
         }
     }
 }
+
+impl Serialize for SecurityMonitoringRuleTypeCreate {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SecurityMonitoringRuleTypeCreate {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "application_security" => Self::APPLICATION_SECURITY,
+            "log_detection" => Self::LOG_DETECTION,
+            "workload_security" => Self::WORKLOAD_SECURITY,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_security_monitoring_rule_type_read.rs b/src/datadogV2/model/model_security_monitoring_rule_type_read.rs
index 5f612e06d..7f6e87aee 100644
--- a/src/datadogV2/model/model_security_monitoring_rule_type_read.rs
+++ b/src/datadogV2/model/model_security_monitoring_rule_type_read.rs
@@ -2,20 +2,15 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SecurityMonitoringRuleTypeRead {
-    #[serde(rename = "log_detection")]
     LOG_DETECTION,
-    #[serde(rename = "infrastructure_configuration")]
     INFRASTRUCTURE_CONFIGURATION,
-    #[serde(rename = "workload_security")]
     WORKLOAD_SECURITY,
-    #[serde(rename = "cloud_configuration")]
     CLOUD_CONFIGURATION,
-    #[serde(rename = "application_security")]
     APPLICATION_SECURITY,
 }
 
@@ -30,3 +25,36 @@ impl ToString for SecurityMonitoringRuleTypeRead {
         }
     }
 }
+
+impl Serialize for SecurityMonitoringRuleTypeRead {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SecurityMonitoringRuleTypeRead {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "log_detection" => Self::LOG_DETECTION,
+            "infrastructure_configuration" => Self::INFRASTRUCTURE_CONFIGURATION,
+            "workload_security" => Self::WORKLOAD_SECURITY,
+            "cloud_configuration" => Self::CLOUD_CONFIGURATION,
+            "application_security" => Self::APPLICATION_SECURITY,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_security_monitoring_signal_archive_reason.rs b/src/datadogV2/model/model_security_monitoring_signal_archive_reason.rs
index 2bf0ee6b3..99da37ab9 100644
--- a/src/datadogV2/model/model_security_monitoring_signal_archive_reason.rs
+++ b/src/datadogV2/model/model_security_monitoring_signal_archive_reason.rs
@@ -2,20 +2,15 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SecurityMonitoringSignalArchiveReason {
-    #[serde(rename = "none")]
     NONE,
-    #[serde(rename = "false_positive")]
     FALSE_POSITIVE,
-    #[serde(rename = "testing_or_maintenance")]
     TESTING_OR_MAINTENANCE,
-    #[serde(rename = "investigated_case_opened")]
     INVESTIGATED_CASE_OPENED,
-    #[serde(rename = "other")]
     OTHER,
 }
 
@@ -30,3 +25,36 @@ impl ToString for SecurityMonitoringSignalArchiveReason {
         }
     }
 }
+
+impl Serialize for SecurityMonitoringSignalArchiveReason {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SecurityMonitoringSignalArchiveReason {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "none" => Self::NONE,
+            "false_positive" => Self::FALSE_POSITIVE,
+            "testing_or_maintenance" => Self::TESTING_OR_MAINTENANCE,
+            "investigated_case_opened" => Self::INVESTIGATED_CASE_OPENED,
+            "other" => Self::OTHER,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_security_monitoring_signal_metadata_type.rs b/src/datadogV2/model/model_security_monitoring_signal_metadata_type.rs
index 72cf30c92..72b56db0a 100644
--- a/src/datadogV2/model/model_security_monitoring_signal_metadata_type.rs
+++ b/src/datadogV2/model/model_security_monitoring_signal_metadata_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SecurityMonitoringSignalMetadataType {
-    #[serde(rename = "signal_metadata")]
     SIGNAL_METADATA,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SecurityMonitoringSignalMetadataType {
         }
     }
 }
+
+impl Serialize for SecurityMonitoringSignalMetadataType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SecurityMonitoringSignalMetadataType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "signal_metadata" => Self::SIGNAL_METADATA,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_security_monitoring_signal_rule_type.rs b/src/datadogV2/model/model_security_monitoring_signal_rule_type.rs
index fc42f1c62..5e57a1daf 100644
--- a/src/datadogV2/model/model_security_monitoring_signal_rule_type.rs
+++ b/src/datadogV2/model/model_security_monitoring_signal_rule_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SecurityMonitoringSignalRuleType {
-    #[serde(rename = "signal_correlation")]
     SIGNAL_CORRELATION,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SecurityMonitoringSignalRuleType {
         }
     }
 }
+
+impl Serialize for SecurityMonitoringSignalRuleType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SecurityMonitoringSignalRuleType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "signal_correlation" => Self::SIGNAL_CORRELATION,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_security_monitoring_signal_state.rs b/src/datadogV2/model/model_security_monitoring_signal_state.rs
index 1e16be5c7..86b606438 100644
--- a/src/datadogV2/model/model_security_monitoring_signal_state.rs
+++ b/src/datadogV2/model/model_security_monitoring_signal_state.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SecurityMonitoringSignalState {
-    #[serde(rename = "open")]
     OPEN,
-    #[serde(rename = "archived")]
     ARCHIVED,
-    #[serde(rename = "under_review")]
     UNDER_REVIEW,
 }
 
@@ -24,3 +21,34 @@ impl ToString for SecurityMonitoringSignalState {
         }
     }
 }
+
+impl Serialize for SecurityMonitoringSignalState {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SecurityMonitoringSignalState {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "open" => Self::OPEN,
+            "archived" => Self::ARCHIVED,
+            "under_review" => Self::UNDER_REVIEW,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_security_monitoring_signal_type.rs b/src/datadogV2/model/model_security_monitoring_signal_type.rs
index 3ec68b76f..bb544a331 100644
--- a/src/datadogV2/model/model_security_monitoring_signal_type.rs
+++ b/src/datadogV2/model/model_security_monitoring_signal_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SecurityMonitoringSignalType {
-    #[serde(rename = "signal")]
     SIGNAL,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SecurityMonitoringSignalType {
         }
     }
 }
+
+impl Serialize for SecurityMonitoringSignalType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SecurityMonitoringSignalType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "signal" => Self::SIGNAL,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_security_monitoring_signals_sort.rs b/src/datadogV2/model/model_security_monitoring_signals_sort.rs
index 166d227e3..71d91096a 100644
--- a/src/datadogV2/model/model_security_monitoring_signals_sort.rs
+++ b/src/datadogV2/model/model_security_monitoring_signals_sort.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SecurityMonitoringSignalsSort {
-    #[serde(rename = "timestamp")]
     TIMESTAMP_ASCENDING,
-    #[serde(rename = "-timestamp")]
     TIMESTAMP_DESCENDING,
 }
 
@@ -21,3 +19,33 @@ impl ToString for SecurityMonitoringSignalsSort {
         }
     }
 }
+
+impl Serialize for SecurityMonitoringSignalsSort {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SecurityMonitoringSignalsSort {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "timestamp" => Self::TIMESTAMP_ASCENDING,
+            "-timestamp" => Self::TIMESTAMP_DESCENDING,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_sensitive_data_scanner_configuration_type.rs b/src/datadogV2/model/model_sensitive_data_scanner_configuration_type.rs
index d61d6e004..4435332f6 100644
--- a/src/datadogV2/model/model_sensitive_data_scanner_configuration_type.rs
+++ b/src/datadogV2/model/model_sensitive_data_scanner_configuration_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SensitiveDataScannerConfigurationType {
-    #[serde(rename = "sensitive_data_scanner_configuration")]
     SENSITIVE_DATA_SCANNER_CONFIGURATIONS,
 }
 
@@ -20,3 +19,32 @@ impl ToString for SensitiveDataScannerConfigurationType {
         }
     }
 }
+
+impl Serialize for SensitiveDataScannerConfigurationType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SensitiveDataScannerConfigurationType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "sensitive_data_scanner_configuration" => Self::SENSITIVE_DATA_SCANNER_CONFIGURATIONS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_sensitive_data_scanner_group_type.rs b/src/datadogV2/model/model_sensitive_data_scanner_group_type.rs
index a0036737a..809956719 100644
--- a/src/datadogV2/model/model_sensitive_data_scanner_group_type.rs
+++ b/src/datadogV2/model/model_sensitive_data_scanner_group_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SensitiveDataScannerGroupType {
-    #[serde(rename = "sensitive_data_scanner_group")]
     SENSITIVE_DATA_SCANNER_GROUP,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SensitiveDataScannerGroupType {
         }
     }
 }
+
+impl Serialize for SensitiveDataScannerGroupType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SensitiveDataScannerGroupType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "sensitive_data_scanner_group" => Self::SENSITIVE_DATA_SCANNER_GROUP,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_sensitive_data_scanner_product.rs b/src/datadogV2/model/model_sensitive_data_scanner_product.rs
index f9d9bc3cb..f8a41a61c 100644
--- a/src/datadogV2/model/model_sensitive_data_scanner_product.rs
+++ b/src/datadogV2/model/model_sensitive_data_scanner_product.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SensitiveDataScannerProduct {
-    #[serde(rename = "logs")]
     LOGS,
-    #[serde(rename = "rum")]
     RUM,
-    #[serde(rename = "events")]
     EVENTS,
-    #[serde(rename = "apm")]
     APM,
 }
 
@@ -27,3 +23,35 @@ impl ToString for SensitiveDataScannerProduct {
         }
     }
 }
+
+impl Serialize for SensitiveDataScannerProduct {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SensitiveDataScannerProduct {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "logs" => Self::LOGS,
+            "rum" => Self::RUM,
+            "events" => Self::EVENTS,
+            "apm" => Self::APM,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_sensitive_data_scanner_rule_type.rs b/src/datadogV2/model/model_sensitive_data_scanner_rule_type.rs
index 6130d8d79..20baea978 100644
--- a/src/datadogV2/model/model_sensitive_data_scanner_rule_type.rs
+++ b/src/datadogV2/model/model_sensitive_data_scanner_rule_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SensitiveDataScannerRuleType {
-    #[serde(rename = "sensitive_data_scanner_rule")]
     SENSITIVE_DATA_SCANNER_RULE,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SensitiveDataScannerRuleType {
         }
     }
 }
+
+impl Serialize for SensitiveDataScannerRuleType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SensitiveDataScannerRuleType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "sensitive_data_scanner_rule" => Self::SENSITIVE_DATA_SCANNER_RULE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_sensitive_data_scanner_standard_pattern_type.rs b/src/datadogV2/model/model_sensitive_data_scanner_standard_pattern_type.rs
index 9b05c9ada..d7aca7b72 100644
--- a/src/datadogV2/model/model_sensitive_data_scanner_standard_pattern_type.rs
+++ b/src/datadogV2/model/model_sensitive_data_scanner_standard_pattern_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SensitiveDataScannerStandardPatternType {
-    #[serde(rename = "sensitive_data_scanner_standard_pattern")]
     SENSITIVE_DATA_SCANNER_STANDARD_PATTERN,
 }
 
@@ -20,3 +19,34 @@ impl ToString for SensitiveDataScannerStandardPatternType {
         }
     }
 }
+
+impl Serialize for SensitiveDataScannerStandardPatternType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SensitiveDataScannerStandardPatternType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "sensitive_data_scanner_standard_pattern" => {
+                Self::SENSITIVE_DATA_SCANNER_STANDARD_PATTERN
+            }
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_sensitive_data_scanner_text_replacement_type.rs b/src/datadogV2/model/model_sensitive_data_scanner_text_replacement_type.rs
index 8a3fab2ad..a9244599c 100644
--- a/src/datadogV2/model/model_sensitive_data_scanner_text_replacement_type.rs
+++ b/src/datadogV2/model/model_sensitive_data_scanner_text_replacement_type.rs
@@ -2,20 +2,15 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SensitiveDataScannerTextReplacementType {
-    #[serde(rename = "none")]
     NONE,
-    #[serde(rename = "hash")]
     HASH,
-    #[serde(rename = "replacement_string")]
     REPLACEMENT_STRING,
-    #[serde(rename = "partial_replacement_from_beginning")]
     PARTIAL_REPLACEMENT_FROM_BEGINNING,
-    #[serde(rename = "partial_replacement_from_end")]
     PARTIAL_REPLACEMENT_FROM_END,
 }
 
@@ -32,3 +27,36 @@ impl ToString for SensitiveDataScannerTextReplacementType {
         }
     }
 }
+
+impl Serialize for SensitiveDataScannerTextReplacementType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SensitiveDataScannerTextReplacementType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "none" => Self::NONE,
+            "hash" => Self::HASH,
+            "replacement_string" => Self::REPLACEMENT_STRING,
+            "partial_replacement_from_beginning" => Self::PARTIAL_REPLACEMENT_FROM_BEGINNING,
+            "partial_replacement_from_end" => Self::PARTIAL_REPLACEMENT_FROM_END,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_service_definition_schema_versions.rs b/src/datadogV2/model/model_service_definition_schema_versions.rs
index ff6f7b5f1..b18babc7c 100644
--- a/src/datadogV2/model/model_service_definition_schema_versions.rs
+++ b/src/datadogV2/model/model_service_definition_schema_versions.rs
@@ -2,18 +2,14 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ServiceDefinitionSchemaVersions {
-    #[serde(rename = "v1")]
     V1,
-    #[serde(rename = "v2")]
     V2,
-    #[serde(rename = "v2.1")]
     V2_1,
-    #[serde(rename = "v2.2")]
     V2_2,
 }
 
@@ -27,3 +23,35 @@ impl ToString for ServiceDefinitionSchemaVersions {
         }
     }
 }
+
+impl Serialize for ServiceDefinitionSchemaVersions {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ServiceDefinitionSchemaVersions {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "v1" => Self::V1,
+            "v2" => Self::V2,
+            "v2.1" => Self::V2_1,
+            "v2.2" => Self::V2_2,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_service_definition_v1_resource_type.rs b/src/datadogV2/model/model_service_definition_v1_resource_type.rs
index 173a7b4b3..4dc7319b3 100644
--- a/src/datadogV2/model/model_service_definition_v1_resource_type.rs
+++ b/src/datadogV2/model/model_service_definition_v1_resource_type.rs
@@ -2,28 +2,19 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ServiceDefinitionV1ResourceType {
-    #[serde(rename = "doc")]
     DOC,
-    #[serde(rename = "wiki")]
     WIKI,
-    #[serde(rename = "runbook")]
     RUNBOOK,
-    #[serde(rename = "url")]
     URL,
-    #[serde(rename = "repo")]
     REPO,
-    #[serde(rename = "dashboard")]
     DASHBOARD,
-    #[serde(rename = "oncall")]
     ONCALL,
-    #[serde(rename = "code")]
     CODE,
-    #[serde(rename = "link")]
     LINK,
 }
 
@@ -42,3 +33,40 @@ impl ToString for ServiceDefinitionV1ResourceType {
         }
     }
 }
+
+impl Serialize for ServiceDefinitionV1ResourceType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ServiceDefinitionV1ResourceType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "doc" => Self::DOC,
+            "wiki" => Self::WIKI,
+            "runbook" => Self::RUNBOOK,
+            "url" => Self::URL,
+            "repo" => Self::REPO,
+            "dashboard" => Self::DASHBOARD,
+            "oncall" => Self::ONCALL,
+            "code" => Self::CODE,
+            "link" => Self::LINK,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_service_definition_v1_version.rs b/src/datadogV2/model/model_service_definition_v1_version.rs
index 948c5c594..a9ef83456 100644
--- a/src/datadogV2/model/model_service_definition_v1_version.rs
+++ b/src/datadogV2/model/model_service_definition_v1_version.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ServiceDefinitionV1Version {
-    #[serde(rename = "v1")]
     V1,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ServiceDefinitionV1Version {
         }
     }
 }
+
+impl Serialize for ServiceDefinitionV1Version {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ServiceDefinitionV1Version {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "v1" => Self::V1,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_service_definition_v2_dot1_email_type.rs b/src/datadogV2/model/model_service_definition_v2_dot1_email_type.rs
index dcdacb480..e03af4044 100644
--- a/src/datadogV2/model/model_service_definition_v2_dot1_email_type.rs
+++ b/src/datadogV2/model/model_service_definition_v2_dot1_email_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ServiceDefinitionV2Dot1EmailType {
-    #[serde(rename = "email")]
     EMAIL,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ServiceDefinitionV2Dot1EmailType {
         }
     }
 }
+
+impl Serialize for ServiceDefinitionV2Dot1EmailType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ServiceDefinitionV2Dot1EmailType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "email" => Self::EMAIL,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_service_definition_v2_dot1_link_type.rs b/src/datadogV2/model/model_service_definition_v2_dot1_link_type.rs
index 5cf9bc992..6d36d5ad4 100644
--- a/src/datadogV2/model/model_service_definition_v2_dot1_link_type.rs
+++ b/src/datadogV2/model/model_service_definition_v2_dot1_link_type.rs
@@ -2,20 +2,15 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ServiceDefinitionV2Dot1LinkType {
-    #[serde(rename = "doc")]
     DOC,
-    #[serde(rename = "repo")]
     REPO,
-    #[serde(rename = "runbook")]
     RUNBOOK,
-    #[serde(rename = "dashboard")]
     DASHBOARD,
-    #[serde(rename = "other")]
     OTHER,
 }
 
@@ -30,3 +25,36 @@ impl ToString for ServiceDefinitionV2Dot1LinkType {
         }
     }
 }
+
+impl Serialize for ServiceDefinitionV2Dot1LinkType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ServiceDefinitionV2Dot1LinkType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "doc" => Self::DOC,
+            "repo" => Self::REPO,
+            "runbook" => Self::RUNBOOK,
+            "dashboard" => Self::DASHBOARD,
+            "other" => Self::OTHER,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_service_definition_v2_dot1_ms_teams_type.rs b/src/datadogV2/model/model_service_definition_v2_dot1_ms_teams_type.rs
index 150100f4a..5dadaa0fc 100644
--- a/src/datadogV2/model/model_service_definition_v2_dot1_ms_teams_type.rs
+++ b/src/datadogV2/model/model_service_definition_v2_dot1_ms_teams_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ServiceDefinitionV2Dot1MSTeamsType {
-    #[serde(rename = "microsoft-teams")]
     MICROSOFT_TEAMS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ServiceDefinitionV2Dot1MSTeamsType {
         }
     }
 }
+
+impl Serialize for ServiceDefinitionV2Dot1MSTeamsType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ServiceDefinitionV2Dot1MSTeamsType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "microsoft-teams" => Self::MICROSOFT_TEAMS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_service_definition_v2_dot1_opsgenie_region.rs b/src/datadogV2/model/model_service_definition_v2_dot1_opsgenie_region.rs
index 5e48a61a0..126a16c6c 100644
--- a/src/datadogV2/model/model_service_definition_v2_dot1_opsgenie_region.rs
+++ b/src/datadogV2/model/model_service_definition_v2_dot1_opsgenie_region.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ServiceDefinitionV2Dot1OpsgenieRegion {
-    #[serde(rename = "US")]
     US,
-    #[serde(rename = "EU")]
     EU,
 }
 
@@ -21,3 +19,33 @@ impl ToString for ServiceDefinitionV2Dot1OpsgenieRegion {
         }
     }
 }
+
+impl Serialize for ServiceDefinitionV2Dot1OpsgenieRegion {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ServiceDefinitionV2Dot1OpsgenieRegion {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "US" => Self::US,
+            "EU" => Self::EU,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_service_definition_v2_dot1_slack_type.rs b/src/datadogV2/model/model_service_definition_v2_dot1_slack_type.rs
index 002eb1d21..98b2af047 100644
--- a/src/datadogV2/model/model_service_definition_v2_dot1_slack_type.rs
+++ b/src/datadogV2/model/model_service_definition_v2_dot1_slack_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ServiceDefinitionV2Dot1SlackType {
-    #[serde(rename = "slack")]
     SLACK,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ServiceDefinitionV2Dot1SlackType {
         }
     }
 }
+
+impl Serialize for ServiceDefinitionV2Dot1SlackType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ServiceDefinitionV2Dot1SlackType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "slack" => Self::SLACK,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_service_definition_v2_dot1_version.rs b/src/datadogV2/model/model_service_definition_v2_dot1_version.rs
index 36963bf22..d959ee581 100644
--- a/src/datadogV2/model/model_service_definition_v2_dot1_version.rs
+++ b/src/datadogV2/model/model_service_definition_v2_dot1_version.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ServiceDefinitionV2Dot1Version {
-    #[serde(rename = "v2.1")]
     V2_1,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ServiceDefinitionV2Dot1Version {
         }
     }
 }
+
+impl Serialize for ServiceDefinitionV2Dot1Version {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ServiceDefinitionV2Dot1Version {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "v2.1" => Self::V2_1,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_service_definition_v2_dot2_opsgenie_region.rs b/src/datadogV2/model/model_service_definition_v2_dot2_opsgenie_region.rs
index 7608f4a0d..7be98738d 100644
--- a/src/datadogV2/model/model_service_definition_v2_dot2_opsgenie_region.rs
+++ b/src/datadogV2/model/model_service_definition_v2_dot2_opsgenie_region.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ServiceDefinitionV2Dot2OpsgenieRegion {
-    #[serde(rename = "US")]
     US,
-    #[serde(rename = "EU")]
     EU,
 }
 
@@ -21,3 +19,33 @@ impl ToString for ServiceDefinitionV2Dot2OpsgenieRegion {
         }
     }
 }
+
+impl Serialize for ServiceDefinitionV2Dot2OpsgenieRegion {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ServiceDefinitionV2Dot2OpsgenieRegion {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "US" => Self::US,
+            "EU" => Self::EU,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_service_definition_v2_dot2_type.rs b/src/datadogV2/model/model_service_definition_v2_dot2_type.rs
index 23ddf825e..f6a10d1ca 100644
--- a/src/datadogV2/model/model_service_definition_v2_dot2_type.rs
+++ b/src/datadogV2/model/model_service_definition_v2_dot2_type.rs
@@ -2,24 +2,17 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ServiceDefinitionV2Dot2Type {
-    #[serde(rename = "web")]
     WEB,
-    #[serde(rename = "db")]
     DB,
-    #[serde(rename = "cache")]
     CACHE,
-    #[serde(rename = "function")]
     FUNCTION,
-    #[serde(rename = "browser")]
     BROSWER,
-    #[serde(rename = "mobile")]
     MOBILE,
-    #[serde(rename = "custom")]
     CUSTOM,
 }
 
@@ -36,3 +29,38 @@ impl ToString for ServiceDefinitionV2Dot2Type {
         }
     }
 }
+
+impl Serialize for ServiceDefinitionV2Dot2Type {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ServiceDefinitionV2Dot2Type {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "web" => Self::WEB,
+            "db" => Self::DB,
+            "cache" => Self::CACHE,
+            "function" => Self::FUNCTION,
+            "browser" => Self::BROSWER,
+            "mobile" => Self::MOBILE,
+            "custom" => Self::CUSTOM,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_service_definition_v2_dot2_version.rs b/src/datadogV2/model/model_service_definition_v2_dot2_version.rs
index 8d4ad8c81..689e91aee 100644
--- a/src/datadogV2/model/model_service_definition_v2_dot2_version.rs
+++ b/src/datadogV2/model/model_service_definition_v2_dot2_version.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ServiceDefinitionV2Dot2Version {
-    #[serde(rename = "v2.2")]
     V2_2,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ServiceDefinitionV2Dot2Version {
         }
     }
 }
+
+impl Serialize for ServiceDefinitionV2Dot2Version {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ServiceDefinitionV2Dot2Version {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "v2.2" => Self::V2_2,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_service_definition_v2_email_type.rs b/src/datadogV2/model/model_service_definition_v2_email_type.rs
index ff3a06d46..9eb5742a5 100644
--- a/src/datadogV2/model/model_service_definition_v2_email_type.rs
+++ b/src/datadogV2/model/model_service_definition_v2_email_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ServiceDefinitionV2EmailType {
-    #[serde(rename = "email")]
     EMAIL,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ServiceDefinitionV2EmailType {
         }
     }
 }
+
+impl Serialize for ServiceDefinitionV2EmailType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ServiceDefinitionV2EmailType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "email" => Self::EMAIL,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_service_definition_v2_link_type.rs b/src/datadogV2/model/model_service_definition_v2_link_type.rs
index b660b2d47..b59e237df 100644
--- a/src/datadogV2/model/model_service_definition_v2_link_type.rs
+++ b/src/datadogV2/model/model_service_definition_v2_link_type.rs
@@ -2,28 +2,19 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ServiceDefinitionV2LinkType {
-    #[serde(rename = "doc")]
     DOC,
-    #[serde(rename = "wiki")]
     WIKI,
-    #[serde(rename = "runbook")]
     RUNBOOK,
-    #[serde(rename = "url")]
     URL,
-    #[serde(rename = "repo")]
     REPO,
-    #[serde(rename = "dashboard")]
     DASHBOARD,
-    #[serde(rename = "oncall")]
     ONCALL,
-    #[serde(rename = "code")]
     CODE,
-    #[serde(rename = "link")]
     LINK,
 }
 
@@ -42,3 +33,40 @@ impl ToString for ServiceDefinitionV2LinkType {
         }
     }
 }
+
+impl Serialize for ServiceDefinitionV2LinkType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ServiceDefinitionV2LinkType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "doc" => Self::DOC,
+            "wiki" => Self::WIKI,
+            "runbook" => Self::RUNBOOK,
+            "url" => Self::URL,
+            "repo" => Self::REPO,
+            "dashboard" => Self::DASHBOARD,
+            "oncall" => Self::ONCALL,
+            "code" => Self::CODE,
+            "link" => Self::LINK,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_service_definition_v2_ms_teams_type.rs b/src/datadogV2/model/model_service_definition_v2_ms_teams_type.rs
index 79660028f..1c6274ae4 100644
--- a/src/datadogV2/model/model_service_definition_v2_ms_teams_type.rs
+++ b/src/datadogV2/model/model_service_definition_v2_ms_teams_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ServiceDefinitionV2MSTeamsType {
-    #[serde(rename = "microsoft-teams")]
     MICROSOFT_TEAMS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ServiceDefinitionV2MSTeamsType {
         }
     }
 }
+
+impl Serialize for ServiceDefinitionV2MSTeamsType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ServiceDefinitionV2MSTeamsType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "microsoft-teams" => Self::MICROSOFT_TEAMS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_service_definition_v2_opsgenie_region.rs b/src/datadogV2/model/model_service_definition_v2_opsgenie_region.rs
index 870a086a2..b853b9fcb 100644
--- a/src/datadogV2/model/model_service_definition_v2_opsgenie_region.rs
+++ b/src/datadogV2/model/model_service_definition_v2_opsgenie_region.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ServiceDefinitionV2OpsgenieRegion {
-    #[serde(rename = "US")]
     US,
-    #[serde(rename = "EU")]
     EU,
 }
 
@@ -21,3 +19,33 @@ impl ToString for ServiceDefinitionV2OpsgenieRegion {
         }
     }
 }
+
+impl Serialize for ServiceDefinitionV2OpsgenieRegion {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ServiceDefinitionV2OpsgenieRegion {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "US" => Self::US,
+            "EU" => Self::EU,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_service_definition_v2_slack_type.rs b/src/datadogV2/model/model_service_definition_v2_slack_type.rs
index 4becc43f6..ef098c515 100644
--- a/src/datadogV2/model/model_service_definition_v2_slack_type.rs
+++ b/src/datadogV2/model/model_service_definition_v2_slack_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ServiceDefinitionV2SlackType {
-    #[serde(rename = "slack")]
     SLACK,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ServiceDefinitionV2SlackType {
         }
     }
 }
+
+impl Serialize for ServiceDefinitionV2SlackType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ServiceDefinitionV2SlackType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "slack" => Self::SLACK,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_service_definition_v2_version.rs b/src/datadogV2/model/model_service_definition_v2_version.rs
index 552865861..f75b8b1ec 100644
--- a/src/datadogV2/model/model_service_definition_v2_version.rs
+++ b/src/datadogV2/model/model_service_definition_v2_version.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ServiceDefinitionV2Version {
-    #[serde(rename = "v2")]
     V2,
 }
 
@@ -18,3 +17,32 @@ impl ToString for ServiceDefinitionV2Version {
         }
     }
 }
+
+impl Serialize for ServiceDefinitionV2Version {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ServiceDefinitionV2Version {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "v2" => Self::V2,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_sort_direction.rs b/src/datadogV2/model/model_sort_direction.rs
index 45661274d..745b85c95 100644
--- a/src/datadogV2/model/model_sort_direction.rs
+++ b/src/datadogV2/model/model_sort_direction.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SortDirection {
-    #[serde(rename = "desc")]
     DESC,
-    #[serde(rename = "asc")]
     ASC,
 }
 
@@ -21,3 +19,33 @@ impl ToString for SortDirection {
         }
     }
 }
+
+impl Serialize for SortDirection {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SortDirection {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "desc" => Self::DESC,
+            "asc" => Self::ASC,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_spans_aggregate_bucket_type.rs b/src/datadogV2/model/model_spans_aggregate_bucket_type.rs
index da59297e7..56a73ad7c 100644
--- a/src/datadogV2/model/model_spans_aggregate_bucket_type.rs
+++ b/src/datadogV2/model/model_spans_aggregate_bucket_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SpansAggregateBucketType {
-    #[serde(rename = "bucket")]
     BUCKET,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SpansAggregateBucketType {
         }
     }
 }
+
+impl Serialize for SpansAggregateBucketType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SpansAggregateBucketType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "bucket" => Self::BUCKET,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_spans_aggregate_request_type.rs b/src/datadogV2/model/model_spans_aggregate_request_type.rs
index 2ecf19862..d97654242 100644
--- a/src/datadogV2/model/model_spans_aggregate_request_type.rs
+++ b/src/datadogV2/model/model_spans_aggregate_request_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SpansAggregateRequestType {
-    #[serde(rename = "aggregate_request")]
     AGGREGATE_REQUEST,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SpansAggregateRequestType {
         }
     }
 }
+
+impl Serialize for SpansAggregateRequestType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SpansAggregateRequestType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "aggregate_request" => Self::AGGREGATE_REQUEST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_spans_aggregate_response_status.rs b/src/datadogV2/model/model_spans_aggregate_response_status.rs
index 25ebeaece..2d5494f56 100644
--- a/src/datadogV2/model/model_spans_aggregate_response_status.rs
+++ b/src/datadogV2/model/model_spans_aggregate_response_status.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SpansAggregateResponseStatus {
-    #[serde(rename = "done")]
     DONE,
-    #[serde(rename = "timeout")]
     TIMEOUT,
 }
 
@@ -21,3 +19,33 @@ impl ToString for SpansAggregateResponseStatus {
         }
     }
 }
+
+impl Serialize for SpansAggregateResponseStatus {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SpansAggregateResponseStatus {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "done" => Self::DONE,
+            "timeout" => Self::TIMEOUT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_spans_aggregate_sort_type.rs b/src/datadogV2/model/model_spans_aggregate_sort_type.rs
index 6f365f9f4..4aa7caf98 100644
--- a/src/datadogV2/model/model_spans_aggregate_sort_type.rs
+++ b/src/datadogV2/model/model_spans_aggregate_sort_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SpansAggregateSortType {
-    #[serde(rename = "alphabetical")]
     ALPHABETICAL,
-    #[serde(rename = "measure")]
     MEASURE,
 }
 
@@ -21,3 +19,33 @@ impl ToString for SpansAggregateSortType {
         }
     }
 }
+
+impl Serialize for SpansAggregateSortType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SpansAggregateSortType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "alphabetical" => Self::ALPHABETICAL,
+            "measure" => Self::MEASURE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_spans_aggregation_function.rs b/src/datadogV2/model/model_spans_aggregation_function.rs
index 8e3ffd69d..a64860611 100644
--- a/src/datadogV2/model/model_spans_aggregation_function.rs
+++ b/src/datadogV2/model/model_spans_aggregation_function.rs
@@ -2,34 +2,22 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SpansAggregationFunction {
-    #[serde(rename = "count")]
     COUNT,
-    #[serde(rename = "cardinality")]
     CARDINALITY,
-    #[serde(rename = "pc75")]
     PERCENTILE_75,
-    #[serde(rename = "pc90")]
     PERCENTILE_90,
-    #[serde(rename = "pc95")]
     PERCENTILE_95,
-    #[serde(rename = "pc98")]
     PERCENTILE_98,
-    #[serde(rename = "pc99")]
     PERCENTILE_99,
-    #[serde(rename = "sum")]
     SUM,
-    #[serde(rename = "min")]
     MIN,
-    #[serde(rename = "max")]
     MAX,
-    #[serde(rename = "avg")]
     AVG,
-    #[serde(rename = "median")]
     MEDIAN,
 }
 
@@ -51,3 +39,43 @@ impl ToString for SpansAggregationFunction {
         }
     }
 }
+
+impl Serialize for SpansAggregationFunction {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SpansAggregationFunction {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "count" => Self::COUNT,
+            "cardinality" => Self::CARDINALITY,
+            "pc75" => Self::PERCENTILE_75,
+            "pc90" => Self::PERCENTILE_90,
+            "pc95" => Self::PERCENTILE_95,
+            "pc98" => Self::PERCENTILE_98,
+            "pc99" => Self::PERCENTILE_99,
+            "sum" => Self::SUM,
+            "min" => Self::MIN,
+            "max" => Self::MAX,
+            "avg" => Self::AVG,
+            "median" => Self::MEDIAN,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_spans_compute_type.rs b/src/datadogV2/model/model_spans_compute_type.rs
index 35c9ad92b..136b64b4e 100644
--- a/src/datadogV2/model/model_spans_compute_type.rs
+++ b/src/datadogV2/model/model_spans_compute_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SpansComputeType {
-    #[serde(rename = "timeseries")]
     TIMESERIES,
-    #[serde(rename = "total")]
     TOTAL,
 }
 
@@ -21,3 +19,33 @@ impl ToString for SpansComputeType {
         }
     }
 }
+
+impl Serialize for SpansComputeType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SpansComputeType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "timeseries" => Self::TIMESERIES,
+            "total" => Self::TOTAL,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_spans_list_request_type.rs b/src/datadogV2/model/model_spans_list_request_type.rs
index 14aa6127e..ec37fab84 100644
--- a/src/datadogV2/model/model_spans_list_request_type.rs
+++ b/src/datadogV2/model/model_spans_list_request_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SpansListRequestType {
-    #[serde(rename = "search_request")]
     SEARCH_REQUEST,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SpansListRequestType {
         }
     }
 }
+
+impl Serialize for SpansListRequestType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SpansListRequestType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "search_request" => Self::SEARCH_REQUEST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_spans_metric_compute_aggregation_type.rs b/src/datadogV2/model/model_spans_metric_compute_aggregation_type.rs
index 9bfe71c10..8d13848ab 100644
--- a/src/datadogV2/model/model_spans_metric_compute_aggregation_type.rs
+++ b/src/datadogV2/model/model_spans_metric_compute_aggregation_type.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SpansMetricComputeAggregationType {
-    #[serde(rename = "count")]
     COUNT,
-    #[serde(rename = "distribution")]
     DISTRIBUTION,
 }
 
@@ -21,3 +19,33 @@ impl ToString for SpansMetricComputeAggregationType {
         }
     }
 }
+
+impl Serialize for SpansMetricComputeAggregationType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SpansMetricComputeAggregationType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "count" => Self::COUNT,
+            "distribution" => Self::DISTRIBUTION,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_spans_metric_type.rs b/src/datadogV2/model/model_spans_metric_type.rs
index 202046dc1..8e84bb8d0 100644
--- a/src/datadogV2/model/model_spans_metric_type.rs
+++ b/src/datadogV2/model/model_spans_metric_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SpansMetricType {
-    #[serde(rename = "spans_metrics")]
     SPANS_METRICS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SpansMetricType {
         }
     }
 }
+
+impl Serialize for SpansMetricType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SpansMetricType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "spans_metrics" => Self::SPANS_METRICS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_spans_sort.rs b/src/datadogV2/model/model_spans_sort.rs
index 8c5450e39..116495cf3 100644
--- a/src/datadogV2/model/model_spans_sort.rs
+++ b/src/datadogV2/model/model_spans_sort.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SpansSort {
-    #[serde(rename = "timestamp")]
     TIMESTAMP_ASCENDING,
-    #[serde(rename = "-timestamp")]
     TIMESTAMP_DESCENDING,
 }
 
@@ -21,3 +19,33 @@ impl ToString for SpansSort {
         }
     }
 }
+
+impl Serialize for SpansSort {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SpansSort {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "timestamp" => Self::TIMESTAMP_ASCENDING,
+            "-timestamp" => Self::TIMESTAMP_DESCENDING,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_spans_sort_order.rs b/src/datadogV2/model/model_spans_sort_order.rs
index 3bb12025d..10d4ab9b1 100644
--- a/src/datadogV2/model/model_spans_sort_order.rs
+++ b/src/datadogV2/model/model_spans_sort_order.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SpansSortOrder {
-    #[serde(rename = "asc")]
     ASCENDING,
-    #[serde(rename = "desc")]
     DESCENDING,
 }
 
@@ -21,3 +19,33 @@ impl ToString for SpansSortOrder {
         }
     }
 }
+
+impl Serialize for SpansSortOrder {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SpansSortOrder {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "asc" => Self::ASCENDING,
+            "desc" => Self::DESCENDING,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_spans_type.rs b/src/datadogV2/model/model_spans_type.rs
index 4e9818b60..b697c0713 100644
--- a/src/datadogV2/model/model_spans_type.rs
+++ b/src/datadogV2/model/model_spans_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum SpansType {
-    #[serde(rename = "spans")]
     SPANS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for SpansType {
         }
     }
 }
+
+impl Serialize for SpansType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SpansType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "spans" => Self::SPANS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_state.rs b/src/datadogV2/model/model_state.rs
index 062ae0eec..f017cc3aa 100644
--- a/src/datadogV2/model/model_state.rs
+++ b/src/datadogV2/model/model_state.rs
@@ -2,16 +2,13 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum State {
-    #[serde(rename = "pass")]
     PASS,
-    #[serde(rename = "fail")]
     FAIL,
-    #[serde(rename = "skip")]
     SKIP,
 }
 
@@ -24,3 +21,34 @@ impl ToString for State {
         }
     }
 }
+
+impl Serialize for State {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for State {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "pass" => Self::PASS,
+            "fail" => Self::FAIL,
+            "skip" => Self::SKIP,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_team_link_type.rs b/src/datadogV2/model/model_team_link_type.rs
index cf8955ebe..bbe5e6082 100644
--- a/src/datadogV2/model/model_team_link_type.rs
+++ b/src/datadogV2/model/model_team_link_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum TeamLinkType {
-    #[serde(rename = "team_links")]
     TEAM_LINKS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for TeamLinkType {
         }
     }
 }
+
+impl Serialize for TeamLinkType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TeamLinkType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "team_links" => Self::TEAM_LINKS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_team_permission_setting_serializer_action.rs b/src/datadogV2/model/model_team_permission_setting_serializer_action.rs
index cf980d038..92cdcc1fb 100644
--- a/src/datadogV2/model/model_team_permission_setting_serializer_action.rs
+++ b/src/datadogV2/model/model_team_permission_setting_serializer_action.rs
@@ -2,14 +2,12 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum TeamPermissionSettingSerializerAction {
-    #[serde(rename = "manage_membership")]
     MANAGE_MEMBERSHIP,
-    #[serde(rename = "edit")]
     EDIT,
 }
 
@@ -21,3 +19,33 @@ impl ToString for TeamPermissionSettingSerializerAction {
         }
     }
 }
+
+impl Serialize for TeamPermissionSettingSerializerAction {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TeamPermissionSettingSerializerAction {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "manage_membership" => Self::MANAGE_MEMBERSHIP,
+            "edit" => Self::EDIT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_team_permission_setting_type.rs b/src/datadogV2/model/model_team_permission_setting_type.rs
index ed4091bca..8ecb1f395 100644
--- a/src/datadogV2/model/model_team_permission_setting_type.rs
+++ b/src/datadogV2/model/model_team_permission_setting_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum TeamPermissionSettingType {
-    #[serde(rename = "team_permission_settings")]
     TEAM_PERMISSION_SETTINGS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for TeamPermissionSettingType {
         }
     }
 }
+
+impl Serialize for TeamPermissionSettingType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TeamPermissionSettingType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "team_permission_settings" => Self::TEAM_PERMISSION_SETTINGS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_team_permission_setting_value.rs b/src/datadogV2/model/model_team_permission_setting_value.rs
index 5dc45b0fa..04b373619 100644
--- a/src/datadogV2/model/model_team_permission_setting_value.rs
+++ b/src/datadogV2/model/model_team_permission_setting_value.rs
@@ -2,20 +2,15 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum TeamPermissionSettingValue {
-    #[serde(rename = "admins")]
     ADMINS,
-    #[serde(rename = "members")]
     MEMBERS,
-    #[serde(rename = "organization")]
     ORGANIZATION,
-    #[serde(rename = "user_access_manage")]
     USER_ACCESS_MANAGE,
-    #[serde(rename = "teams_manage")]
     TEAMS_MANAGE,
 }
 
@@ -30,3 +25,36 @@ impl ToString for TeamPermissionSettingValue {
         }
     }
 }
+
+impl Serialize for TeamPermissionSettingValue {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TeamPermissionSettingValue {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "admins" => Self::ADMINS,
+            "members" => Self::MEMBERS,
+            "organization" => Self::ORGANIZATION,
+            "user_access_manage" => Self::USER_ACCESS_MANAGE,
+            "teams_manage" => Self::TEAMS_MANAGE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_team_type.rs b/src/datadogV2/model/model_team_type.rs
index 09ca646d2..a43270d59 100644
--- a/src/datadogV2/model/model_team_type.rs
+++ b/src/datadogV2/model/model_team_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum TeamType {
-    #[serde(rename = "team")]
     TEAM,
 }
 
@@ -18,3 +17,32 @@ impl ToString for TeamType {
         }
     }
 }
+
+impl Serialize for TeamType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TeamType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "team" => Self::TEAM,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_teams_field.rs b/src/datadogV2/model/model_teams_field.rs
index caa9acfb4..3a4393d70 100644
--- a/src/datadogV2/model/model_teams_field.rs
+++ b/src/datadogV2/model/model_teams_field.rs
@@ -2,40 +2,25 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum TeamsField {
-    #[serde(rename = "id")]
     ID,
-    #[serde(rename = "name")]
     NAME,
-    #[serde(rename = "handle")]
     HANDLE,
-    #[serde(rename = "summary")]
     SUMMARY,
-    #[serde(rename = "description")]
     DESCRIPTION,
-    #[serde(rename = "avatar")]
     AVATAR,
-    #[serde(rename = "banner")]
     BANNER,
-    #[serde(rename = "visible_modules")]
     VISIBLE_MODULES,
-    #[serde(rename = "hidden_modules")]
     HIDDEN_MODULES,
-    #[serde(rename = "created_at")]
     CREATED_AT,
-    #[serde(rename = "modified_at")]
     MODIFIED_AT,
-    #[serde(rename = "user_count")]
     USER_COUNT,
-    #[serde(rename = "link_count")]
     LINK_COUNT,
-    #[serde(rename = "team_links")]
     TEAM_LINKS,
-    #[serde(rename = "user_team_permissions")]
     USER_TEAM_PERMISSIONS,
 }
 
@@ -60,3 +45,46 @@ impl ToString for TeamsField {
         }
     }
 }
+
+impl Serialize for TeamsField {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TeamsField {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "id" => Self::ID,
+            "name" => Self::NAME,
+            "handle" => Self::HANDLE,
+            "summary" => Self::SUMMARY,
+            "description" => Self::DESCRIPTION,
+            "avatar" => Self::AVATAR,
+            "banner" => Self::BANNER,
+            "visible_modules" => Self::VISIBLE_MODULES,
+            "hidden_modules" => Self::HIDDEN_MODULES,
+            "created_at" => Self::CREATED_AT,
+            "modified_at" => Self::MODIFIED_AT,
+            "user_count" => Self::USER_COUNT,
+            "link_count" => Self::LINK_COUNT,
+            "team_links" => Self::TEAM_LINKS,
+            "user_team_permissions" => Self::USER_TEAM_PERMISSIONS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_timeseries_formula_request_type.rs b/src/datadogV2/model/model_timeseries_formula_request_type.rs
index 39daa2962..a844ed44f 100644
--- a/src/datadogV2/model/model_timeseries_formula_request_type.rs
+++ b/src/datadogV2/model/model_timeseries_formula_request_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum TimeseriesFormulaRequestType {
-    #[serde(rename = "timeseries_request")]
     TIMESERIES_REQUEST,
 }
 
@@ -18,3 +17,32 @@ impl ToString for TimeseriesFormulaRequestType {
         }
     }
 }
+
+impl Serialize for TimeseriesFormulaRequestType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TimeseriesFormulaRequestType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "timeseries_request" => Self::TIMESERIES_REQUEST,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_timeseries_formula_response_type.rs b/src/datadogV2/model/model_timeseries_formula_response_type.rs
index 895b8697f..8ab0b40ed 100644
--- a/src/datadogV2/model/model_timeseries_formula_response_type.rs
+++ b/src/datadogV2/model/model_timeseries_formula_response_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum TimeseriesFormulaResponseType {
-    #[serde(rename = "timeseries_response")]
     TIMESERIES_RESPONSE,
 }
 
@@ -18,3 +17,32 @@ impl ToString for TimeseriesFormulaResponseType {
         }
     }
 }
+
+impl Serialize for TimeseriesFormulaResponseType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for TimeseriesFormulaResponseType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "timeseries_response" => Self::TIMESERIES_RESPONSE,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_usage_time_series_type.rs b/src/datadogV2/model/model_usage_time_series_type.rs
index 44e03a58c..9cf33ee77 100644
--- a/src/datadogV2/model/model_usage_time_series_type.rs
+++ b/src/datadogV2/model/model_usage_time_series_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum UsageTimeSeriesType {
-    #[serde(rename = "usage_timeseries")]
     USAGE_TIMESERIES,
 }
 
@@ -18,3 +17,32 @@ impl ToString for UsageTimeSeriesType {
         }
     }
 }
+
+impl Serialize for UsageTimeSeriesType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for UsageTimeSeriesType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "usage_timeseries" => Self::USAGE_TIMESERIES,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_user_invitations_type.rs b/src/datadogV2/model/model_user_invitations_type.rs
index 5122677b1..f872a1c59 100644
--- a/src/datadogV2/model/model_user_invitations_type.rs
+++ b/src/datadogV2/model/model_user_invitations_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum UserInvitationsType {
-    #[serde(rename = "user_invitations")]
     USER_INVITATIONS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for UserInvitationsType {
         }
     }
 }
+
+impl Serialize for UserInvitationsType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for UserInvitationsType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "user_invitations" => Self::USER_INVITATIONS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_user_team_permission_type.rs b/src/datadogV2/model/model_user_team_permission_type.rs
index b7d9af5ff..fda815c0d 100644
--- a/src/datadogV2/model/model_user_team_permission_type.rs
+++ b/src/datadogV2/model/model_user_team_permission_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum UserTeamPermissionType {
-    #[serde(rename = "user_team_permissions")]
     USER_TEAM_PERMISSIONS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for UserTeamPermissionType {
         }
     }
 }
+
+impl Serialize for UserTeamPermissionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for UserTeamPermissionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "user_team_permissions" => Self::USER_TEAM_PERMISSIONS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_user_team_role.rs b/src/datadogV2/model/model_user_team_role.rs
index fe653e320..4e203f05c 100644
--- a/src/datadogV2/model/model_user_team_role.rs
+++ b/src/datadogV2/model/model_user_team_role.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum UserTeamRole {
-    #[serde(rename = "admin")]
     ADMIN,
 }
 
@@ -18,3 +17,32 @@ impl ToString for UserTeamRole {
         }
     }
 }
+
+impl Serialize for UserTeamRole {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for UserTeamRole {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "admin" => Self::ADMIN,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_user_team_team_type.rs b/src/datadogV2/model/model_user_team_team_type.rs
index 25dfd1960..ceda6af65 100644
--- a/src/datadogV2/model/model_user_team_team_type.rs
+++ b/src/datadogV2/model/model_user_team_team_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum UserTeamTeamType {
-    #[serde(rename = "team")]
     TEAM,
 }
 
@@ -18,3 +17,32 @@ impl ToString for UserTeamTeamType {
         }
     }
 }
+
+impl Serialize for UserTeamTeamType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for UserTeamTeamType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "team" => Self::TEAM,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_user_team_type.rs b/src/datadogV2/model/model_user_team_type.rs
index 5a82ec8f6..5a862286b 100644
--- a/src/datadogV2/model/model_user_team_type.rs
+++ b/src/datadogV2/model/model_user_team_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum UserTeamType {
-    #[serde(rename = "team_memberships")]
     TEAM_MEMBERSHIPS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for UserTeamType {
         }
     }
 }
+
+impl Serialize for UserTeamType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for UserTeamType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "team_memberships" => Self::TEAM_MEMBERSHIPS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_user_team_user_type.rs b/src/datadogV2/model/model_user_team_user_type.rs
index 83d4babb6..1cc971b14 100644
--- a/src/datadogV2/model/model_user_team_user_type.rs
+++ b/src/datadogV2/model/model_user_team_user_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum UserTeamUserType {
-    #[serde(rename = "users")]
     USERS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for UserTeamUserType {
         }
     }
 }
+
+impl Serialize for UserTeamUserType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for UserTeamUserType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "users" => Self::USERS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_users_type.rs b/src/datadogV2/model/model_users_type.rs
index db985e887..c465465fb 100644
--- a/src/datadogV2/model/model_users_type.rs
+++ b/src/datadogV2/model/model_users_type.rs
@@ -2,12 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum UsersType {
-    #[serde(rename = "users")]
     USERS,
 }
 
@@ -18,3 +17,32 @@ impl ToString for UsersType {
         }
     }
 }
+
+impl Serialize for UsersType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for UsersType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "users" => Self::USERS,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}
diff --git a/src/datadogV2/model/model_widget_live_span.rs b/src/datadogV2/model/model_widget_live_span.rs
index c206c9d21..fcd7e3563 100644
--- a/src/datadogV2/model/model_widget_live_span.rs
+++ b/src/datadogV2/model/model_widget_live_span.rs
@@ -2,40 +2,25 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WidgetLiveSpan {
-    #[serde(rename = "1m")]
     PAST_ONE_MINUTE,
-    #[serde(rename = "5m")]
     PAST_FIVE_MINUTES,
-    #[serde(rename = "10m")]
     PAST_TEN_MINUTES,
-    #[serde(rename = "15m")]
     PAST_FIFTEEN_MINUTES,
-    #[serde(rename = "30m")]
     PAST_THIRTY_MINUTES,
-    #[serde(rename = "1h")]
     PAST_ONE_HOUR,
-    #[serde(rename = "4h")]
     PAST_FOUR_HOURS,
-    #[serde(rename = "1d")]
     PAST_ONE_DAY,
-    #[serde(rename = "2d")]
     PAST_TWO_DAYS,
-    #[serde(rename = "1w")]
     PAST_ONE_WEEK,
-    #[serde(rename = "1mo")]
     PAST_ONE_MONTH,
-    #[serde(rename = "3mo")]
     PAST_THREE_MONTHS,
-    #[serde(rename = "6mo")]
     PAST_SIX_MONTHS,
-    #[serde(rename = "1y")]
     PAST_ONE_YEAR,
-    #[serde(rename = "alert")]
     ALERT,
 }
 
@@ -60,3 +45,46 @@ impl ToString for WidgetLiveSpan {
         }
     }
 }
+
+impl Serialize for WidgetLiveSpan {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WidgetLiveSpan {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "1m" => Self::PAST_ONE_MINUTE,
+            "5m" => Self::PAST_FIVE_MINUTES,
+            "10m" => Self::PAST_TEN_MINUTES,
+            "15m" => Self::PAST_FIFTEEN_MINUTES,
+            "30m" => Self::PAST_THIRTY_MINUTES,
+            "1h" => Self::PAST_ONE_HOUR,
+            "4h" => Self::PAST_FOUR_HOURS,
+            "1d" => Self::PAST_ONE_DAY,
+            "2d" => Self::PAST_TWO_DAYS,
+            "1w" => Self::PAST_ONE_WEEK,
+            "1mo" => Self::PAST_ONE_MONTH,
+            "3mo" => Self::PAST_THREE_MONTHS,
+            "6mo" => Self::PAST_SIX_MONTHS,
+            "1y" => Self::PAST_ONE_YEAR,
+            "alert" => Self::ALERT,
+            _ => {
+                return Err(serde::de::Error::custom(format!(
+                    "Invalid value for SyntheticsDeviceID: {}",
+                    s
+                )))
+            }
+        })
+    }
+}