From b7a5fdbc4394cd202ac2062587e9a7ed52c1891f Mon Sep 17 00:00:00 2001 From: "ci.datadog-api-spec" Date: Thu, 23 Jul 2026 18:21:05 +0000 Subject: [PATCH] Regenerate client from commit ec8ccab of spec repo --- .generator/schemas/v2/openapi.yaml | 13 +++++ src/datadogV2/model/mod.rs | 2 + src/datadogV2/model/model_schedule_trigger.rs | 31 +++++++++++ ...model_schedule_trigger_overlap_behavior.rs | 51 +++++++++++++++++++ 4 files changed, 97 insertions(+) create mode 100644 src/datadogV2/model/model_schedule_trigger_overlap_behavior.rs diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index 4331313d34..9fc7576047 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -87680,6 +87680,8 @@ 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: "" @@ -87687,6 +87689,17 @@ components: 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: diff --git a/src/datadogV2/model/mod.rs b/src/datadogV2/model/mod.rs index d5c40717ad..e84f504982 100644 --- a/src/datadogV2/model/mod.rs +++ b/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; diff --git a/src/datadogV2/model/model_schedule_trigger.rs b/src/datadogV2/model/model_schedule_trigger.rs index 7eac43ab91..234895fde3 100644 --- a/src/datadogV2/model/model_schedule_trigger.rs +++ b/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, /// 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, @@ -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 = 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::()? { 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, diff --git a/src/datadogV2/model/model_schedule_trigger_overlap_behavior.rs b/src/datadogV2/model/model_schedule_trigger_overlap_behavior.rs new file mode 100644 index 0000000000..a9de500df9 --- /dev/null +++ b/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(&self, serializer: S) -> Result + 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(deserializer: D) -> Result + 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()), + }), + }) + } +}