Add datastore trigger to workflows public API

.generator/schemas/v2/openapi.yaml

@@ -14697,6 +14697,23 @@ components:
       x-enum-varnames:
       - NONE
       - UUID
+    DatastoreTrigger:
+      description: Trigger a workflow from a Datastore. For automatic triggering a
+        handle must be configured and the workflow must be published.
+      properties:
+        rateLimit:
+          $ref: '#/components/schemas/TriggerRateLimit'
+      type: object
+    DatastoreTriggerWrapper:
+      description: Schema for a Datastore-based trigger.
+      properties:
+        datastoreTrigger:
+          $ref: '#/components/schemas/DatastoreTrigger'
+        startStepNames:
+          $ref: '#/components/schemas/StartStepNames'
+      required:
+      - datastoreTrigger
+      type: object
     Date:
       description: Date as Unix timestamp in milliseconds.
       example: 1722439510282
@@ -47710,6 +47727,7 @@ components:
       - $ref: '#/components/schemas/CaseTriggerWrapper'
       - $ref: '#/components/schemas/ChangeEventTriggerWrapper'
       - $ref: '#/components/schemas/DatabaseMonitoringTriggerWrapper'
+      - $ref: '#/components/schemas/DatastoreTriggerWrapper'
       - $ref: '#/components/schemas/DashboardTriggerWrapper'
       - $ref: '#/components/schemas/GithubWebhookTriggerWrapper'
       - $ref: '#/components/schemas/IncidentTriggerWrapper'

src/datadogV2/model/mod.rs

@@ -6242,6 +6242,10 @@ pub mod model_change_event_trigger_wrapper;
 pub use self::model_change_event_trigger_wrapper::ChangeEventTriggerWrapper;
 pub mod model_database_monitoring_trigger_wrapper;
 pub use self::model_database_monitoring_trigger_wrapper::DatabaseMonitoringTriggerWrapper;
+pub mod model_datastore_trigger_wrapper;
+pub use self::model_datastore_trigger_wrapper::DatastoreTriggerWrapper;
+pub mod model_datastore_trigger;
+pub use self::model_datastore_trigger::DatastoreTrigger;
 pub mod model_dashboard_trigger_wrapper;
 pub use self::model_dashboard_trigger_wrapper::DashboardTriggerWrapper;
 pub mod model_github_webhook_trigger_wrapper;

src/datadogV2/model/model_datastore_trigger.rs

@@ -0,0 +1,105 @@
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2019-Present Datadog, Inc.
+use serde::de::{Error, MapAccess, Visitor};
+use serde::{Deserialize, Deserializer, Serialize};
+use serde_with::skip_serializing_none;
+use std::fmt::{self, Formatter};
+
+/// Trigger a workflow from a Datastore. For automatic triggering a handle must be configured and the workflow must be published.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct DatastoreTrigger {
+    /// Defines a rate limit for a trigger.
+    #[serde(rename = "rateLimit")]
+    pub rate_limit: Option<crate::datadogV2::model::TriggerRateLimit>,
+    #[serde(flatten)]
+    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
+    #[serde(skip)]
+    #[serde(default)]
+    pub(crate) _unparsed: bool,
+}
+
+impl DatastoreTrigger {
+    pub fn new() -> DatastoreTrigger {
+        DatastoreTrigger {
+            rate_limit: None,
+            additional_properties: std::collections::BTreeMap::new(),
+            _unparsed: false,
+        }
+    }
+
+    pub fn rate_limit(mut self, value: crate::datadogV2::model::TriggerRateLimit) -> Self {
+        self.rate_limit = Some(value);
+        self
+    }
+
+    pub fn additional_properties(
+        mut self,
+        value: std::collections::BTreeMap<String, serde_json::Value>,
+    ) -> Self {
+        self.additional_properties = value;
+        self
+    }
+}
+
+impl Default for DatastoreTrigger {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<'de> Deserialize<'de> for DatastoreTrigger {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct DatastoreTriggerVisitor;
+        impl<'a> Visitor<'a> for DatastoreTriggerVisitor {
+            type Value = DatastoreTrigger;
+
+            fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result {
+                f.write_str("a mapping")
+            }
+
+            fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
+            where
+                M: MapAccess<'a>,
+            {
+                let mut rate_limit: Option<crate::datadogV2::model::TriggerRateLimit> = None;
+                let mut additional_properties: std::collections::BTreeMap<
+                    String,
+                    serde_json::Value,
+                > = std::collections::BTreeMap::new();
+                let mut _unparsed = false;
+
+                while let Some((k, v)) = map.next_entry::<String, serde_json::Value>()? {
+                    match k.as_str() {
+                        "rateLimit" => {
+                            if v.is_null() {
+                                continue;
+                            }
+                            rate_limit = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                        }
+                        &_ => {
+                            if let Ok(value) = serde_json::from_value(v.clone()) {
+                                additional_properties.insert(k, value);
+                            }
+                        }
+                    }
+                }
+
+                let content = DatastoreTrigger {
+                    rate_limit,
+                    additional_properties,
+                    _unparsed,
+                };
+
+                Ok(content)
+            }
+        }
+
+        deserializer.deserialize_any(DatastoreTriggerVisitor)
+    }
+}

src/datadogV2/model/model_datastore_trigger_wrapper.rs

@@ -0,0 +1,114 @@
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2019-Present Datadog, Inc.
+use serde::de::{Error, MapAccess, Visitor};
+use serde::{Deserialize, Deserializer, Serialize};
+use serde_with::skip_serializing_none;
+use std::fmt::{self, Formatter};
+
+/// Schema for a Datastore-based trigger.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct DatastoreTriggerWrapper {
+    /// Trigger a workflow from a Datastore. For automatic triggering a handle must be configured and the workflow must be published.
+    #[serde(rename = "datastoreTrigger")]
+    pub datastore_trigger: crate::datadogV2::model::DatastoreTrigger,
+    /// A list of steps that run first after a trigger fires.
+    #[serde(rename = "startStepNames")]
+    pub start_step_names: Option<Vec<String>>,
+    #[serde(flatten)]
+    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
+    #[serde(skip)]
+    #[serde(default)]
+    pub(crate) _unparsed: bool,
+}
+
+impl DatastoreTriggerWrapper {
+    pub fn new(
+        datastore_trigger: crate::datadogV2::model::DatastoreTrigger,
+    ) -> DatastoreTriggerWrapper {
+        DatastoreTriggerWrapper {
+            datastore_trigger,
+            start_step_names: None,
+            additional_properties: std::collections::BTreeMap::new(),
+            _unparsed: false,
+        }
+    }
+
+    pub fn start_step_names(mut self, value: Vec<String>) -> Self {
+        self.start_step_names = Some(value);
+        self
+    }
+
+    pub fn additional_properties(
+        mut self,
+        value: std::collections::BTreeMap<String, serde_json::Value>,
+    ) -> Self {
+        self.additional_properties = value;
+        self
+    }
+}
+
+impl<'de> Deserialize<'de> for DatastoreTriggerWrapper {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct DatastoreTriggerWrapperVisitor;
+        impl<'a> Visitor<'a> for DatastoreTriggerWrapperVisitor {
+            type Value = DatastoreTriggerWrapper;
+
+            fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result {
+                f.write_str("a mapping")
+            }
+
+            fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
+            where
+                M: MapAccess<'a>,
+            {
+                let mut datastore_trigger: Option<crate::datadogV2::model::DatastoreTrigger> = None;
+                let mut start_step_names: Option<Vec<String>> = None;
+                let mut additional_properties: std::collections::BTreeMap<
+                    String,
+                    serde_json::Value,
+                > = std::collections::BTreeMap::new();
+                let mut _unparsed = false;
+
+                while let Some((k, v)) = map.next_entry::<String, serde_json::Value>()? {
+                    match k.as_str() {
+                        "datastoreTrigger" => {
+                            datastore_trigger =
+                                Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                        }
+                        "startStepNames" => {
+                            if v.is_null() {
+                                continue;
+                            }
+                            start_step_names =
+                                Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                        }
+                        &_ => {
+                            if let Ok(value) = serde_json::from_value(v.clone()) {
+                                additional_properties.insert(k, value);
+                            }
+                        }
+                    }
+                }
+                let datastore_trigger = datastore_trigger
+                    .ok_or_else(|| M::Error::missing_field("datastore_trigger"))?;
+
+                let content = DatastoreTriggerWrapper {
+                    datastore_trigger,
+                    start_step_names,
+                    additional_properties,
+                    _unparsed,
+                };
+
+                Ok(content)
+            }
+        }
+
+        deserializer.deserialize_any(DatastoreTriggerWrapperVisitor)
+    }
+}

src/datadogV2/model/model_trigger.rs

@@ -15,6 +15,7 @@ pub enum Trigger {
     DatabaseMonitoringTriggerWrapper(
         Box<crate::datadogV2::model::DatabaseMonitoringTriggerWrapper>,
     ),
+    DatastoreTriggerWrapper(Box<crate::datadogV2::model::DatastoreTriggerWrapper>),
     DashboardTriggerWrapper(Box<crate::datadogV2::model::DashboardTriggerWrapper>),
     GithubWebhookTriggerWrapper(Box<crate::datadogV2::model::GithubWebhookTriggerWrapper>),
     IncidentTriggerWrapper(Box<crate::datadogV2::model::IncidentTriggerWrapper>),
@@ -72,6 +73,14 @@ impl<'de> Deserialize<'de> for Trigger {
                 return Ok(Trigger::DatabaseMonitoringTriggerWrapper(_v));
             }
         }
+        if let Ok(_v) = serde_json::from_value::<
+            Box<crate::datadogV2::model::DatastoreTriggerWrapper>,
+        >(value.clone())
+        {
+            if !_v._unparsed {
+                return Ok(Trigger::DatastoreTriggerWrapper(_v));
+            }
+        }
         if let Ok(_v) = serde_json::from_value::<
             Box<crate::datadogV2::model::DashboardTriggerWrapper>,
         >(value.clone())