Uncomment edit dataset block, add dataset limitations into endpoint descriptions (#807)

Co-authored-by: ci.datadog-api-spec <[email protected]>

Author: api-clients-generation-pipeline[bot]

.generated-info

@@ -1,4 +1,4 @@
 {
-  "spec_repo_commit": "d51e9a8",
-  "generated": "2025-07-25 13:28:36.413"
+  "spec_repo_commit": "e4f653f",
+  "generated": "2025-07-25 14:12:09.627"
 }

.generator/schemas/v2/openapi.yaml

@@ -12478,7 +12478,14 @@ components:
       - type
       type: object
     Dataset:
-      description: Dataset object.
+      description: "Dataset object.\n\n### Datasets Constraints\n- **Tag Limit per
+        Dataset**:\n  - Each restricted dataset supports a maximum of 10 key:value
+        pairs per product.\n\n- **Tag Key Rules per Telemetry Type**:\n  - Only one
+        tag key or attribute may be used to define access within a single telemetry
+        type.\n  - The same or different tag key may be used across different telemetry
+        types.\n\n- **Tag Value Uniqueness**:\n  - Tag values must be unique within
+        a single dataset.\n  - A tag value used in one dataset cannot be reused in
+        another dataset of the same telemetry type."
       properties:
         attributes:
           $ref: '#/components/schemas/DatasetAttributes'
@@ -12556,6 +12563,14 @@ components:
       required:
       - data
       type: object
+    DatasetUpdateRequest:
+      description: Edit request for a dataset.
+      properties:
+        data:
+          $ref: '#/components/schemas/Dataset'
+      required:
+      - data
+      type: object
     Date:
       description: Date as Unix timestamp in milliseconds.
       example: 1722439510282
@@ -16083,10 +16098,9 @@ components:
           type: array
         product:
           description: 'Name of the product the dataset is for. Possible values are
-            ''apm'', ''rum'', ''synthetics'',
+            ''apm'', ''rum'',
 
-            ''metrics'', ''logs'', ''sd_repoinfo'', ''error_tracking'', ''cloud_cost'',
-            and ''ml_obs''.'
+            ''metrics'', ''logs'', ''error_tracking'', and ''cloud_cost''.'
           example: logs
           type: string
       required:
@@ -48282,6 +48296,44 @@ paths:
       x-permission:
         operator: OPEN
         permissions: []
+    put:
+      description: Edits the dataset associated with the ID.
+      operationId: UpdateDataset
+      parameters:
+      - $ref: '#/components/parameters/DatasetID'
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/DatasetUpdateRequest'
+        description: Dataset payload
+        required: true
+      responses:
+        '200':
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/DatasetResponseSingle'
+          description: OK
+        '400':
+          $ref: '#/components/responses/BadRequestResponse'
+        '403':
+          $ref: '#/components/responses/NotAuthorizedResponse'
+        '404':
+          $ref: '#/components/responses/NotFoundResponse'
+        '429':
+          $ref: '#/components/responses/TooManyRequestsResponse'
+      security:
+      - apiKeyAuth: []
+        appKeyAuth: []
+      - AuthZ: []
+      summary: Edit a dataset
+      tags:
+      - Datasets
+      x-codegen-request-body-name: body
+      x-permission:
+        operator: OPEN
+        permissions: []
   /api/v2/deletion/data/{product}:
     post:
       description: Creates a data deletion request by providing a query and a timeframe

examples/v2_datasets_UpdateDataset.rs

@@ -0,0 +1,34 @@
+// Edit a dataset returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_datasets::DatasetsAPI;
+use datadog_api_client::datadogV2::model::Dataset;
+use datadog_api_client::datadogV2::model::DatasetAttributes;
+use datadog_api_client::datadogV2::model::DatasetUpdateRequest;
+use datadog_api_client::datadogV2::model::FiltersPerProduct;
+
+#[tokio::main]
+async fn main() {
+    let body = DatasetUpdateRequest::new(
+        Dataset::new(
+            DatasetAttributes::new(
+                "Security Audit Dataset".to_string(),
+                vec!["role:86245fce-0a4e-11f0-92bd-da7ad0900002".to_string()],
+                vec![FiltersPerProduct::new(
+                    vec!["@application.id:ABCD".to_string()],
+                    "logs".to_string(),
+                )],
+            )
+            .created_at(None),
+            "dataset".to_string(),
+        )
+        .id("123e4567-e89b-12d3-a456-426614174000".to_string()),
+    );
+    let configuration = datadog::Configuration::new();
+    let api = DatasetsAPI::with_config(configuration);
+    let resp = api.update_dataset("dataset_id".to_string(), body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

src/datadogV2/api/api_datasets.rs

@@ -42,6 +42,14 @@ pub enum GetDatasetError {
     UnknownValue(serde_json::Value),
 }
 
+/// UpdateDatasetError is a struct for typed errors of method [`DatasetsAPI::update_dataset`]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum UpdateDatasetError {
+    APIErrorResponse(crate::datadogV2::model::APIErrorResponse),
+    UnknownValue(serde_json::Value),
+}
+
 /// Data Access Controls in Datadog is a feature that allows administrators and access managers to regulate
 /// access to sensitive data. By defining Restricted Datasets, you can ensure that only specific teams or roles can
 /// view certain types of telemetry (for example, logs, traces, metrics, and RUM data).
@@ -558,4 +566,159 @@ impl DatasetsAPI {
             Err(datadog::Error::ResponseError(local_error))
         }
     }
+
+    /// Edits the dataset associated with the ID.
+    pub async fn update_dataset(
+        &self,
+        dataset_id: String,
+        body: crate::datadogV2::model::DatasetUpdateRequest,
+    ) -> Result<crate::datadogV2::model::DatasetResponseSingle, datadog::Error<UpdateDatasetError>>
+    {
+        match self.update_dataset_with_http_info(dataset_id, body).await {
+            Ok(response_content) => {
+                if let Some(e) = response_content.entity {
+                    Ok(e)
+                } else {
+                    Err(datadog::Error::Serde(serde::de::Error::custom(
+                        "response content was None",
+                    )))
+                }
+            }
+            Err(err) => Err(err),
+        }
+    }
+
+    /// Edits the dataset associated with the ID.
+    pub async fn update_dataset_with_http_info(
+        &self,
+        dataset_id: String,
+        body: crate::datadogV2::model::DatasetUpdateRequest,
+    ) -> Result<
+        datadog::ResponseContent<crate::datadogV2::model::DatasetResponseSingle>,
+        datadog::Error<UpdateDatasetError>,
+    > {
+        let local_configuration = &self.config;
+        let operation_id = "v2.update_dataset";
+
+        let local_client = &self.client;
+
+        let local_uri_str = format!(
+            "{}/api/v2/datasets/{dataset_id}",
+            local_configuration.get_operation_host(operation_id),
+            dataset_id = datadog::urlencode(dataset_id)
+        );
+        let mut local_req_builder =
+            local_client.request(reqwest::Method::PUT, local_uri_str.as_str());
+
+        // build headers
+        let mut headers = HeaderMap::new();
+        headers.insert("Content-Type", HeaderValue::from_static("application/json"));
+        headers.insert("Accept", HeaderValue::from_static("application/json"));
+
+        // build user agent
+        match HeaderValue::from_str(local_configuration.user_agent.as_str()) {
+            Ok(user_agent) => headers.insert(reqwest::header::USER_AGENT, user_agent),
+            Err(e) => {
+                log::warn!("Failed to parse user agent header: {e}, falling back to default");
+                headers.insert(
+                    reqwest::header::USER_AGENT,
+                    HeaderValue::from_static(datadog::DEFAULT_USER_AGENT.as_str()),
+                )
+            }
+        };
+
+        // build auth
+        if let Some(local_key) = local_configuration.auth_keys.get("apiKeyAuth") {
+            headers.insert(
+                "DD-API-KEY",
+                HeaderValue::from_str(local_key.key.as_str())
+                    .expect("failed to parse DD-API-KEY header"),
+            );
+        };
+        if let Some(local_key) = local_configuration.auth_keys.get("appKeyAuth") {
+            headers.insert(
+                "DD-APPLICATION-KEY",
+                HeaderValue::from_str(local_key.key.as_str())
+                    .expect("failed to parse DD-APPLICATION-KEY header"),
+            );
+        };
+
+        // build body parameters
+        let output = Vec::new();
+        let mut ser = serde_json::Serializer::with_formatter(output, datadog::DDFormatter);
+        if body.serialize(&mut ser).is_ok() {
+            if let Some(content_encoding) = headers.get("Content-Encoding") {
+                match content_encoding.to_str().unwrap_or_default() {
+                    "gzip" => {
+                        let mut enc = GzEncoder::new(Vec::new(), Compression::default());
+                        let _ = enc.write_all(ser.into_inner().as_slice());
+                        match enc.finish() {
+                            Ok(buf) => {
+                                local_req_builder = local_req_builder.body(buf);
+                            }
+                            Err(e) => return Err(datadog::Error::Io(e)),
+                        }
+                    }
+                    "deflate" => {
+                        let mut enc = ZlibEncoder::new(Vec::new(), Compression::default());
+                        let _ = enc.write_all(ser.into_inner().as_slice());
+                        match enc.finish() {
+                            Ok(buf) => {
+                                local_req_builder = local_req_builder.body(buf);
+                            }
+                            Err(e) => return Err(datadog::Error::Io(e)),
+                        }
+                    }
+                    "zstd1" => {
+                        let mut enc = zstd::stream::Encoder::new(Vec::new(), 0).unwrap();
+                        let _ = enc.write_all(ser.into_inner().as_slice());
+                        match enc.finish() {
+                            Ok(buf) => {
+                                local_req_builder = local_req_builder.body(buf);
+                            }
+                            Err(e) => return Err(datadog::Error::Io(e)),
+                        }
+                    }
+                    _ => {
+                        local_req_builder = local_req_builder.body(ser.into_inner());
+                    }
+                }
+            } else {
+                local_req_builder = local_req_builder.body(ser.into_inner());
+            }
+        }
+
+        local_req_builder = local_req_builder.headers(headers);
+        let local_req = local_req_builder.build()?;
+        log::debug!("request content: {:?}", local_req.body());
+        let local_resp = local_client.execute(local_req).await?;
+
+        let local_status = local_resp.status();
+        let local_content = local_resp.text().await?;
+        log::debug!("response content: {}", local_content);
+
+        if !local_status.is_client_error() && !local_status.is_server_error() {
+            match serde_json::from_str::<crate::datadogV2::model::DatasetResponseSingle>(
+                &local_content,
+            ) {
+                Ok(e) => {
+                    return Ok(datadog::ResponseContent {
+                        status: local_status,
+                        content: local_content,
+                        entity: Some(e),
+                    })
+                }
+                Err(e) => return Err(datadog::Error::Serde(e)),
+            };
+        } else {
+            let local_entity: Option<UpdateDatasetError> =
+                serde_json::from_str(&local_content).ok();
+            let local_error = datadog::ResponseContent {
+                status: local_status,
+                content: local_content,
+                entity: local_entity,
+            };
+            Err(datadog::Error::ResponseError(local_error))
+        }
+    }
 }

src/datadogV2/model/mod.rs

@@ -1380,6 +1380,8 @@ pub mod model_dataset_create_request;
 pub use self::model_dataset_create_request::DatasetCreateRequest;
 pub mod model_dataset_response_single;
 pub use self::model_dataset_response_single::DatasetResponseSingle;
+pub mod model_dataset_update_request;
+pub use self::model_dataset_update_request::DatasetUpdateRequest;
 pub mod model_create_data_deletion_request_body;
 pub use self::model_create_data_deletion_request_body::CreateDataDeletionRequestBody;
 pub mod model_create_data_deletion_request_body_data;

src/datadogV2/model/model_dataset.rs

@@ -7,6 +7,18 @@ use serde_with::skip_serializing_none;
 use std::fmt::{self, Formatter};
 
 /// Dataset object.
+///
+/// ### Datasets Constraints
+/// - **Tag Limit per Dataset**:
+///   - Each restricted dataset supports a maximum of 10 key:value pairs per product.
+///
+/// - **Tag Key Rules per Telemetry Type**:
+///   - Only one tag key or attribute may be used to define access within a single telemetry type.
+///   - The same or different tag key may be used across different telemetry types.
+///
+/// - **Tag Value Uniqueness**:
+///   - Tag values must be unique within a single dataset.
+///   - A tag value used in one dataset cannot be reused in another dataset of the same telemetry type.
 #[non_exhaustive]
 #[skip_serializing_none]
 #[derive(Clone, Debug, PartialEq, Serialize)]

src/datadogV2/model/model_dataset_create_request.rs

@@ -12,6 +12,18 @@ use std::fmt::{self, Formatter};
 #[derive(Clone, Debug, PartialEq, Serialize)]
 pub struct DatasetCreateRequest {
     /// Dataset object.
+    ///
+    /// ### Datasets Constraints
+    /// - **Tag Limit per Dataset**:
+    ///   - Each restricted dataset supports a maximum of 10 key:value pairs per product.
+    ///
+    /// - **Tag Key Rules per Telemetry Type**:
+    ///   - Only one tag key or attribute may be used to define access within a single telemetry type.
+    ///   - The same or different tag key may be used across different telemetry types.
+    ///
+    /// - **Tag Value Uniqueness**:
+    ///   - Tag values must be unique within a single dataset.
+    ///   - A tag value used in one dataset cannot be reused in another dataset of the same telemetry type.
     #[serde(rename = "data")]
     pub data: crate::datadogV2::model::Dataset,
     #[serde(flatten)]

src/datadogV2/model/model_dataset_response_single.rs

@@ -12,6 +12,18 @@ use std::fmt::{self, Formatter};
 #[derive(Clone, Debug, PartialEq, Serialize)]
 pub struct DatasetResponseSingle {
     /// Dataset object.
+    ///
+    /// ### Datasets Constraints
+    /// - **Tag Limit per Dataset**:
+    ///   - Each restricted dataset supports a maximum of 10 key:value pairs per product.
+    ///
+    /// - **Tag Key Rules per Telemetry Type**:
+    ///   - Only one tag key or attribute may be used to define access within a single telemetry type.
+    ///   - The same or different tag key may be used across different telemetry types.
+    ///
+    /// - **Tag Value Uniqueness**:
+    ///   - Tag values must be unique within a single dataset.
+    ///   - A tag value used in one dataset cannot be reused in another dataset of the same telemetry type.
     #[serde(rename = "data")]
     pub data: crate::datadogV2::model::Dataset,
     #[serde(flatten)]