Regenerate client from commit dcb0494 of spec repo

Author: ci.datadog-api-spec

.generator/schemas/v2/openapi.yaml

@@ -39721,19 +39721,24 @@ components:
       - DISTRIBUTION
     MetricTagConfigurationMetricTypes:
       default: gauge
-      description: The metric's type.
+      description: The metric's type. Contact your CSM for instructions on how to
+        use the histogram types.
       enum:
       - gauge
       - count
       - rate
       - distribution
+      - exponential_histogram
+      - explicit_histogram
       example: count
       type: string
       x-enum-varnames:
       - GAUGE
       - COUNT
       - RATE
       - DISTRIBUTION
+      - EXPONENTIAL_HISTOGRAM
+      - EXPLICIT_HISTOGRAM
     MetricTagConfigurationResponse:
       description: Response object which includes a single metric's tag configuration.
       properties:
@@ -102212,6 +102217,13 @@ paths:
     get:
       description: Get the list of all critical assets.
       operationId: ListSecurityMonitoringCriticalAssets
+      parameters:
+      - description: Query string.
+        in: query
+        name: query
+        required: false
+        schema:
+          type: string
       responses:
         '200':
           content:

examples/v2_security-monitoring_ListSecurityMonitoringCriticalAssets.rs

@@ -1,12 +1,17 @@
 // Get all critical assets returns "OK" response
 use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::ListSecurityMonitoringCriticalAssetsOptionalParams;
 use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI;
 
 #[tokio::main]
 async fn main() {
     let configuration = datadog::Configuration::new();
     let api = SecurityMonitoringAPI::with_config(configuration);
-    let resp = api.list_security_monitoring_critical_assets().await;
+    let resp = api
+        .list_security_monitoring_critical_assets(
+            ListSecurityMonitoringCriticalAssetsOptionalParams::default(),
+        )
+        .await;
     if let Ok(value) = resp {
         println!("{:#?}", value);
     } else {

src/datadogV2/api/api_security_monitoring.rs

@@ -452,6 +452,22 @@ impl ListSecurityFindingsOptionalParams {
     }
 }
 
+/// ListSecurityMonitoringCriticalAssetsOptionalParams is a struct for passing parameters to the method [`SecurityMonitoringAPI::list_security_monitoring_critical_assets`]
+#[non_exhaustive]
+#[derive(Clone, Default, Debug)]
+pub struct ListSecurityMonitoringCriticalAssetsOptionalParams {
+    /// Query string.
+    pub query: Option<String>,
+}
+
+impl ListSecurityMonitoringCriticalAssetsOptionalParams {
+    /// Query string.
+    pub fn query(mut self, value: String) -> Self {
+        self.query = Some(value);
+        self
+    }
+}
+
 /// ListSecurityMonitoringHistsignalsOptionalParams is a struct for passing parameters to the method [`SecurityMonitoringAPI::list_security_monitoring_histsignals`]
 #[non_exhaustive]
 #[derive(Clone, Default, Debug)]
@@ -9852,12 +9868,13 @@ impl SecurityMonitoringAPI {
     /// Get the list of all critical assets.
     pub async fn list_security_monitoring_critical_assets(
         &self,
+        params: ListSecurityMonitoringCriticalAssetsOptionalParams,
     ) -> Result<
         crate::datadogV2::model::SecurityMonitoringCriticalAssetsResponse,
         datadog::Error<ListSecurityMonitoringCriticalAssetsError>,
     > {
         match self
-            .list_security_monitoring_critical_assets_with_http_info()
+            .list_security_monitoring_critical_assets_with_http_info(params)
             .await
         {
             Ok(response_content) => {
@@ -9876,13 +9893,17 @@ impl SecurityMonitoringAPI {
     /// Get the list of all critical assets.
     pub async fn list_security_monitoring_critical_assets_with_http_info(
         &self,
+        params: ListSecurityMonitoringCriticalAssetsOptionalParams,
     ) -> Result<
         datadog::ResponseContent<crate::datadogV2::model::SecurityMonitoringCriticalAssetsResponse>,
         datadog::Error<ListSecurityMonitoringCriticalAssetsError>,
     > {
         let local_configuration = &self.config;
         let operation_id = "v2.list_security_monitoring_critical_assets";
 
+        // unbox and build optional parameters
+        let query = params.query;
+
         let local_client = &self.client;
 
         let local_uri_str = format!(
@@ -9892,6 +9913,11 @@ impl SecurityMonitoringAPI {
         let mut local_req_builder =
             local_client.request(reqwest::Method::GET, local_uri_str.as_str());
 
+        if let Some(ref local_query_param) = query {
+            local_req_builder =
+                local_req_builder.query(&[("query", &local_query_param.to_string())]);
+        };
+
         // build headers
         let mut headers = HeaderMap::new();
         headers.insert("Accept", HeaderValue::from_static("application/json"));

src/datadogV2/model/model_metric_tag_configuration_attributes.rs

@@ -26,7 +26,7 @@ pub struct MetricTagConfigurationAttributes {
     /// Only present when the `metric_type` is `distribution`.
     #[serde(rename = "include_percentiles")]
     pub include_percentiles: Option<bool>,
-    /// The metric's type.
+    /// The metric's type. Contact your CSM for instructions on how to use the histogram types.
     #[serde(rename = "metric_type")]
     pub metric_type: Option<crate::datadogV2::model::MetricTagConfigurationMetricTypes>,
     /// Timestamp when the tag configuration was last modified.

src/datadogV2/model/model_metric_tag_configuration_create_attributes.rs

@@ -23,7 +23,7 @@ pub struct MetricTagConfigurationCreateAttributes {
     /// Defaults to false. Can only be applied to metrics that have a `metric_type` of `distribution`.
     #[serde(rename = "include_percentiles")]
     pub include_percentiles: Option<bool>,
-    /// The metric's type.
+    /// The metric's type. Contact your CSM for instructions on how to use the histogram types.
     #[serde(rename = "metric_type")]
     pub metric_type: crate::datadogV2::model::MetricTagConfigurationMetricTypes,
     /// A list of tag keys that will be queryable for your metric.

src/datadogV2/model/model_metric_tag_configuration_metric_types.rs

@@ -11,6 +11,8 @@ pub enum MetricTagConfigurationMetricTypes {
     COUNT,
     RATE,
     DISTRIBUTION,
+    EXPONENTIAL_HISTOGRAM,
+    EXPLICIT_HISTOGRAM,
     UnparsedObject(crate::datadog::UnparsedObject),
 }
 
@@ -21,6 +23,8 @@ impl ToString for MetricTagConfigurationMetricTypes {
             Self::COUNT => String::from("count"),
             Self::RATE => String::from("rate"),
             Self::DISTRIBUTION => String::from("distribution"),
+            Self::EXPONENTIAL_HISTOGRAM => String::from("exponential_histogram"),
+            Self::EXPLICIT_HISTOGRAM => String::from("explicit_histogram"),
             Self::UnparsedObject(v) => v.value.to_string(),
         }
     }
@@ -49,6 +53,8 @@ impl<'de> Deserialize<'de> for MetricTagConfigurationMetricTypes {
             "count" => Self::COUNT,
             "rate" => Self::RATE,
             "distribution" => Self::DISTRIBUTION,
+            "exponential_histogram" => Self::EXPONENTIAL_HISTOGRAM,
+            "explicit_histogram" => Self::EXPLICIT_HISTOGRAM,
             _ => Self::UnparsedObject(crate::datadog::UnparsedObject {
                 value: serde_json::Value::String(s.into()),
             }),

tests/scenarios/function_mappings.rs

@@ -19450,20 +19450,26 @@ fn test_v2_list_security_monitoring_critical_assets(
         .v2_api_security_monitoring
         .as_ref()
         .expect("api instance not found");
-    let response = match block_on(api.list_security_monitoring_critical_assets_with_http_info()) {
-        Ok(response) => response,
-        Err(error) => {
-            return match error {
-                Error::ResponseError(e) => {
-                    world.response.code = e.status.as_u16();
-                    if let Some(entity) = e.entity {
-                        world.response.object = serde_json::to_value(entity).unwrap();
+    let query = _parameters
+        .get("query")
+        .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap()));
+    let mut params = datadogV2::api_security_monitoring::ListSecurityMonitoringCriticalAssetsOptionalParams::default();
+    params.query = query;
+    let response =
+        match block_on(api.list_security_monitoring_critical_assets_with_http_info(params)) {
+            Ok(response) => response,
+            Err(error) => {
+                return match error {
+                    Error::ResponseError(e) => {
+                        world.response.code = e.status.as_u16();
+                        if let Some(entity) = e.entity {
+                            world.response.object = serde_json::to_value(entity).unwrap();
+                        }
                     }
-                }
-                _ => panic!("error parsing response: {error}"),
-            };
-        }
-    };
+                    _ => panic!("error parsing response: {error}"),
+                };
+            }
+        };
     world.response.object = serde_json::to_value(response.entity).unwrap();
     world.response.code = response.status.as_u16();
 }