Add workflow schedule overlap behavior

.generator/schemas/v2/openapi.yaml

@@ -87680,13 +87680,26 @@ components:
     ScheduleTrigger:
       description: "Trigger a workflow from a Schedule. The workflow must be published."
       properties:
+        overlapBehavior:
+          $ref: "#/components/schemas/ScheduleTriggerOverlapBehavior"
         rruleExpression:
           description: "Recurrence rule expression for scheduling."
           example: ""
           type: string
       required:
         - rruleExpression
       type: object
+    ScheduleTriggerOverlapBehavior:
+      default: EXCLUSIVE_RUN
+      description: Controls whether a scheduled workflow run may start while another instance is still running.
+      enum:
+        - EXCLUSIVE_RUN
+        - OVERLAP_ALLOWED
+      example: EXCLUSIVE_RUN
+      type: string
+      x-enum-varnames:
+        - EXCLUSIVE_RUN
+        - OVERLAP_ALLOWED
     ScheduleTriggerWrapper:
       description: "Schema for a Schedule-based trigger."
       properties:

src/datadogV2/model/mod.rs

@@ -13878,6 +13878,8 @@ pub mod model_schedule_trigger_wrapper;
 pub use self::model_schedule_trigger_wrapper::ScheduleTriggerWrapper;
 pub mod model_schedule_trigger;
 pub use self::model_schedule_trigger::ScheduleTrigger;
+pub mod model_schedule_trigger_overlap_behavior;
+pub use self::model_schedule_trigger_overlap_behavior::ScheduleTriggerOverlapBehavior;
 pub mod model_security_trigger_wrapper;
 pub use self::model_security_trigger_wrapper::SecurityTriggerWrapper;
 pub mod model_security_trigger;

src/datadogV2/model/model_schedule_trigger.rs

@@ -11,6 +11,9 @@ use std::fmt::{self, Formatter};
 #[skip_serializing_none]
 #[derive(Clone, Debug, PartialEq, Serialize)]
 pub struct ScheduleTrigger {
+    /// Controls whether a scheduled workflow run may start while another instance is still running.
+    #[serde(rename = "overlapBehavior")]
+    pub overlap_behavior: Option<crate::datadogV2::model::ScheduleTriggerOverlapBehavior>,
     /// Recurrence rule expression for scheduling.
     #[serde(rename = "rruleExpression")]
     pub rrule_expression: String,
@@ -24,12 +27,21 @@ pub struct ScheduleTrigger {
 impl ScheduleTrigger {
     pub fn new(rrule_expression: String) -> ScheduleTrigger {
         ScheduleTrigger {
+            overlap_behavior: None,
             rrule_expression,
             additional_properties: std::collections::BTreeMap::new(),
             _unparsed: false,
         }
     }
 
+    pub fn overlap_behavior(
+        mut self,
+        value: crate::datadogV2::model::ScheduleTriggerOverlapBehavior,
+    ) -> Self {
+        self.overlap_behavior = Some(value);
+        self
+    }
+
     pub fn additional_properties(
         mut self,
         value: std::collections::BTreeMap<String, serde_json::Value>,
@@ -56,6 +68,9 @@ impl<'de> Deserialize<'de> for ScheduleTrigger {
             where
                 M: MapAccess<'a>,
             {
+                let mut overlap_behavior: Option<
+                    crate::datadogV2::model::ScheduleTriggerOverlapBehavior,
+                > = None;
                 let mut rrule_expression: Option<String> = None;
                 let mut additional_properties: std::collections::BTreeMap<
                     String,
@@ -65,6 +80,21 @@ impl<'de> Deserialize<'de> for ScheduleTrigger {
 
                 while let Some((k, v)) = map.next_entry::<String, serde_json::Value>()? {
                     match k.as_str() {
+                        "overlapBehavior" => {
+                            if v.is_null() {
+                                continue;
+                            }
+                            overlap_behavior =
+                                Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                            if let Some(ref _overlap_behavior) = overlap_behavior {
+                                match _overlap_behavior {
+                                    crate::datadogV2::model::ScheduleTriggerOverlapBehavior::UnparsedObject(_overlap_behavior) => {
+                                        _unparsed = true;
+                                    },
+                                    _ => {}
+                                }
+                            }
+                        }
                         "rruleExpression" => {
                             rrule_expression =
                                 Some(serde_json::from_value(v).map_err(M::Error::custom)?);
@@ -80,6 +110,7 @@ impl<'de> Deserialize<'de> for ScheduleTrigger {
                     rrule_expression.ok_or_else(|| M::Error::missing_field("rrule_expression"))?;
 
                 let content = ScheduleTrigger {
+                    overlap_behavior,
                     rrule_expression,
                     additional_properties,
                     _unparsed,

src/datadogV2/model/model_schedule_trigger_overlap_behavior.rs

@@ -0,0 +1,51 @@
+// 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::{Deserialize, Deserializer, Serialize, Serializer};
+
+#[non_exhaustive]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum ScheduleTriggerOverlapBehavior {
+    EXCLUSIVE_RUN,
+    OVERLAP_ALLOWED,
+    UnparsedObject(crate::datadog::UnparsedObject),
+}
+
+impl ToString for ScheduleTriggerOverlapBehavior {
+    fn to_string(&self) -> String {
+        match self {
+            Self::EXCLUSIVE_RUN => String::from("EXCLUSIVE_RUN"),
+            Self::OVERLAP_ALLOWED => String::from("OVERLAP_ALLOWED"),
+            Self::UnparsedObject(v) => v.value.to_string(),
+        }
+    }
+}
+
+impl Serialize for ScheduleTriggerOverlapBehavior {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            Self::UnparsedObject(v) => v.serialize(serializer),
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ScheduleTriggerOverlapBehavior {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "EXCLUSIVE_RUN" => Self::EXCLUSIVE_RUN,
+            "OVERLAP_ALLOWED" => Self::OVERLAP_ALLOWED,
+            _ => Self::UnparsedObject(crate::datadog::UnparsedObject {
+                value: serde_json::Value::String(s.into()),
+            }),
+        })
+    }
+}