Regenerate client from commit 335acc5 of spec repo

Author: ci.datadog-api-spec

.generator/schemas/v1/openapi.yaml

@@ -1443,6 +1443,10 @@ components:
           format: date-time
           readOnly: true
           type: string
+        default_timeframe:
+          allOf:
+            - $ref: "#/components/schemas/DashboardDefaultTimeframe"
+          description: The default timeframe applied when opening the dashboard. Set to `null` to clear the dashboard's default timeframe.
         description:
           description: Description of the dashboard.
           nullable: true
@@ -1557,6 +1561,39 @@ components:
       required:
         - data
       type: object
+    DashboardDefaultTimeframe:
+      description: The default timeframe applied when opening the dashboard.
+      nullable: true
+      properties:
+        from:
+          description: Start time in milliseconds since epoch. Required when `type` is `fixed`.
+          format: int64
+          type: integer
+        to:
+          description: End time in milliseconds since epoch. Required when `type` is `fixed`.
+          format: int64
+          type: integer
+        type:
+          $ref: "#/components/schemas/DashboardDefaultTimeframeType"
+        unit:
+          $ref: "#/components/schemas/WidgetLiveSpanUnit"
+        value:
+          description: Value of the live timeframe span. Required when `type` is `live`.
+          format: int64
+          type: integer
+      required:
+        - type
+      type: object
+    DashboardDefaultTimeframeType:
+      description: Type of timeframe.
+      enum:
+        - live
+        - fixed
+      example: live
+      type: string
+      x-enum-varnames:
+        - LIVE
+        - FIXED
     DashboardDeleteResponse:
       description: Response from the delete dashboard call.
       properties:

src/datadogV1/model/mod.rs

@@ -88,6 +88,12 @@ pub mod model_dashboard_restore_request;
 pub use self::model_dashboard_restore_request::DashboardRestoreRequest;
 pub mod model_dashboard;
 pub use self::model_dashboard::Dashboard;
+pub mod model_dashboard_default_timeframe;
+pub use self::model_dashboard_default_timeframe::DashboardDefaultTimeframe;
+pub mod model_dashboard_default_timeframe_type;
+pub use self::model_dashboard_default_timeframe_type::DashboardDefaultTimeframeType;
+pub mod model_widget_live_span_unit;
+pub use self::model_widget_live_span_unit::WidgetLiveSpanUnit;
 pub mod model_dashboard_reflow_type;
 pub use self::model_dashboard_reflow_type::DashboardReflowType;
 pub mod model_dashboard_tab;
@@ -110,8 +116,6 @@ pub mod model_widget_new_live_span;
 pub use self::model_widget_new_live_span::WidgetNewLiveSpan;
 pub mod model_widget_new_live_span_type;
 pub use self::model_widget_new_live_span_type::WidgetNewLiveSpanType;
-pub mod model_widget_live_span_unit;
-pub use self::model_widget_live_span_unit::WidgetLiveSpanUnit;
 pub mod model_widget_new_fixed_span;
 pub use self::model_widget_new_fixed_span::WidgetNewFixedSpan;
 pub mod model_widget_new_fixed_span_type;

src/datadogV1/model/model_dashboard.rs

@@ -25,6 +25,9 @@ pub struct Dashboard {
     /// Creation date of the dashboard.
     #[serde(rename = "created_at")]
     pub created_at: Option<chrono::DateTime<chrono::Utc>>,
+    /// The default timeframe applied when opening the dashboard. Set to `null` to clear the dashboard's default timeframe.
+    #[serde(rename = "default_timeframe")]
+    pub default_timeframe: Option<serde_json::Value>,
     /// Description of the dashboard.
     #[serde(
         rename = "description",
@@ -110,6 +113,7 @@ impl Dashboard {
             author_handle: None,
             author_name: None,
             created_at: None,
+            default_timeframe: None,
             description: None,
             id: None,
             is_read_only: None,
@@ -148,6 +152,12 @@ impl Dashboard {
         self
     }
 
+    #[allow(deprecated)]
+    pub fn default_timeframe(mut self, value: serde_json::Value) -> Self {
+        self.default_timeframe = Some(value);
+        self
+    }
+
     #[allow(deprecated)]
     pub fn description(mut self, value: Option<String>) -> Self {
         self.description = Some(value);
@@ -255,6 +265,7 @@ impl<'de> Deserialize<'de> for Dashboard {
                 let mut author_handle: Option<String> = None;
                 let mut author_name: Option<Option<String>> = None;
                 let mut created_at: Option<chrono::DateTime<chrono::Utc>> = None;
+                let mut default_timeframe: Option<serde_json::Value> = None;
                 let mut description: Option<Option<String>> = None;
                 let mut id: Option<String> = None;
                 let mut is_read_only: Option<bool> = None;
@@ -299,6 +310,13 @@ impl<'de> Deserialize<'de> for Dashboard {
                             }
                             created_at = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
                         }
+                        "default_timeframe" => {
+                            if v.is_null() {
+                                continue;
+                            }
+                            default_timeframe =
+                                Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                        }
                         "description" => {
                             description =
                                 Some(serde_json::from_value(v).map_err(M::Error::custom)?);
@@ -404,6 +422,7 @@ impl<'de> Deserialize<'de> for Dashboard {
                     author_handle,
                     author_name,
                     created_at,
+                    default_timeframe,
                     description,
                     id,
                     is_read_only,

src/datadogV1/model/model_dashboard_default_timeframe.rs

@@ -0,0 +1,181 @@
+// 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};
+
+/// The default timeframe applied when opening the dashboard.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct DashboardDefaultTimeframe {
+    /// Start time in milliseconds since epoch. Required when `type` is `fixed`.
+    #[serde(rename = "from")]
+    pub from: Option<i64>,
+    /// End time in milliseconds since epoch. Required when `type` is `fixed`.
+    #[serde(rename = "to")]
+    pub to: Option<i64>,
+    /// Type of timeframe.
+    #[serde(rename = "type")]
+    pub type_: crate::datadogV1::model::DashboardDefaultTimeframeType,
+    /// Unit of the time span.
+    #[serde(rename = "unit")]
+    pub unit: Option<crate::datadogV1::model::WidgetLiveSpanUnit>,
+    /// Value of the live timeframe span. Required when `type` is `live`.
+    #[serde(rename = "value")]
+    pub value: Option<i64>,
+    #[serde(flatten)]
+    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
+    #[serde(skip)]
+    #[serde(default)]
+    pub(crate) _unparsed: bool,
+}
+
+impl DashboardDefaultTimeframe {
+    pub fn new(
+        type_: crate::datadogV1::model::DashboardDefaultTimeframeType,
+    ) -> DashboardDefaultTimeframe {
+        DashboardDefaultTimeframe {
+            from: None,
+            to: None,
+            type_,
+            unit: None,
+            value: None,
+            additional_properties: std::collections::BTreeMap::new(),
+            _unparsed: false,
+        }
+    }
+
+    pub fn from(mut self, value: i64) -> Self {
+        self.from = Some(value);
+        self
+    }
+
+    pub fn to(mut self, value: i64) -> Self {
+        self.to = Some(value);
+        self
+    }
+
+    pub fn unit(mut self, value: crate::datadogV1::model::WidgetLiveSpanUnit) -> Self {
+        self.unit = Some(value);
+        self
+    }
+
+    pub fn value(mut self, value: i64) -> Self {
+        self.value = 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 DashboardDefaultTimeframe {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct DashboardDefaultTimeframeVisitor;
+        impl<'a> Visitor<'a> for DashboardDefaultTimeframeVisitor {
+            type Value = DashboardDefaultTimeframe;
+
+            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 from: Option<i64> = None;
+                let mut to: Option<i64> = None;
+                let mut type_: Option<crate::datadogV1::model::DashboardDefaultTimeframeType> =
+                    None;
+                let mut unit: Option<crate::datadogV1::model::WidgetLiveSpanUnit> = None;
+                let mut value: Option<i64> = 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() {
+                        "from" => {
+                            if v.is_null() {
+                                continue;
+                            }
+                            from = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                        }
+                        "to" => {
+                            if v.is_null() {
+                                continue;
+                            }
+                            to = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                        }
+                        "type" => {
+                            type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                            if let Some(ref _type_) = type_ {
+                                match _type_ {
+                                    crate::datadogV1::model::DashboardDefaultTimeframeType::UnparsedObject(_type_) => {
+                                        _unparsed = true;
+                                    },
+                                    _ => {}
+                                }
+                            }
+                        }
+                        "unit" => {
+                            if v.is_null() {
+                                continue;
+                            }
+                            unit = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                            if let Some(ref _unit) = unit {
+                                match _unit {
+                                    crate::datadogV1::model::WidgetLiveSpanUnit::UnparsedObject(
+                                        _unit,
+                                    ) => {
+                                        _unparsed = true;
+                                    }
+                                    _ => {}
+                                }
+                            }
+                        }
+                        "value" => {
+                            if v.is_null() {
+                                continue;
+                            }
+                            value = 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 type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?;
+
+                let content = DashboardDefaultTimeframe {
+                    from,
+                    to,
+                    type_,
+                    unit,
+                    value,
+                    additional_properties,
+                    _unparsed,
+                };
+
+                Ok(content)
+            }
+        }
+
+        deserializer.deserialize_any(DashboardDefaultTimeframeVisitor)
+    }
+}

src/datadogV1/model/model_dashboard_default_timeframe_type.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 DashboardDefaultTimeframeType {
+    LIVE,
+    FIXED,
+    UnparsedObject(crate::datadog::UnparsedObject),
+}
+
+impl ToString for DashboardDefaultTimeframeType {
+    fn to_string(&self) -> String {
+        match self {
+            Self::LIVE => String::from("live"),
+            Self::FIXED => String::from("fixed"),
+            Self::UnparsedObject(v) => v.value.to_string(),
+        }
+    }
+}
+
+impl Serialize for DashboardDefaultTimeframeType {
+    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 DashboardDefaultTimeframeType {
+    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,
+            "fixed" => Self::FIXED,
+            _ => Self::UnparsedObject(crate::datadog::UnparsedObject {
+                value: serde_json::Value::String(s.into()),
+            }),
+        })
+    }
+}