Regenerate client from commit 5f4072eb of spec repo

ci.datadog-api-spec · ci.datadog-api-spec · commit 043e2fc972c7 · 2025-03-05T18:06:59.000Z
diff --git a/.apigentools-info b/.apigentools-info
@@ -4,13 +4,13 @@
     "spec_versions": {
         "v1": {
             "apigentools_version": "1.6.6",
-            "regenerated": "2025-03-05 14:38:20.340456",
-            "spec_repo_commit": "0c376cca"
+            "regenerated": "2025-03-05 18:01:21.100831",
+            "spec_repo_commit": "5f4072eb"
         },
         "v2": {
             "apigentools_version": "1.6.6",
-            "regenerated": "2025-03-05 14:38:20.356470",
-            "spec_repo_commit": "0c376cca"
+            "regenerated": "2025-03-05 18:01:21.116060",
+            "spec_repo_commit": "5f4072eb"
         }
     }
 }
diff --git a/.generator/schemas/v1/openapi.yaml b/.generator/schemas/v1/openapi.yaml
@@ -28747,6 +28747,47 @@ paths:
         permissions:
         - logs_modify_indexes
   /api/v1/logs/config/indexes/{name}:
+    delete:
+      description: 'Delete an existing index from your organization. Index deletions
+        are permanent and cannot be reverted.
+
+        You cannot recreate an index with the same name as deleted ones.'
+      operationId: DeleteLogsIndex
+      parameters:
+      - description: Name of the log index.
+        in: path
+        name: name
+        required: true
+        schema:
+          type: string
+      responses:
+        '200':
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/LogsIndex'
+          description: OK
+        '403':
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/APIErrorResponse'
+          description: Forbidden
+        '404':
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/LogsAPIErrorResponse'
+          description: Not Found
+        '429':
+          $ref: '#/components/responses/TooManyRequestsResponse'
+      summary: Delete an index
+      tags:
+      - Logs Indexes
+      x-permission:
+        operator: OR
+        permissions:
+        - logs_modify_indexes
     get:
       description: Get one log index from your organization. This endpoint takes no
         JSON arguments.
diff --git a/examples/v1_logs-indexes_DeleteLogsIndex.rs b/examples/v1_logs-indexes_DeleteLogsIndex.rs
@@ -0,0 +1,15 @@
+// Delete an index returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV1::api_logs_indexes::LogsIndexesAPI;
+
+#[tokio::main]
+async fn main() {
+    let configuration = datadog::Configuration::new();
+    let api = LogsIndexesAPI::with_config(configuration);
+    let resp = api.delete_logs_index("name".to_string()).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}
diff --git a/src/datadogV1/api/api_logs_indexes.rs b/src/datadogV1/api/api_logs_indexes.rs
@@ -19,6 +19,15 @@ pub enum CreateLogsIndexError {
     UnknownValue(serde_json::Value),
 }
 
+/// DeleteLogsIndexError is a struct for typed errors of method [`LogsIndexesAPI::delete_logs_index`]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum DeleteLogsIndexError {
+    APIErrorResponse(crate::datadogV1::model::APIErrorResponse),
+    LogsAPIErrorResponse(crate::datadogV1::model::LogsAPIErrorResponse),
+    UnknownValue(serde_json::Value),
+}
+
 /// GetLogsIndexError is a struct for typed errors of method [`LogsIndexesAPI::get_logs_index`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(untagged)]
@@ -276,6 +285,112 @@ impl LogsIndexesAPI {
         }
     }
 
+    /// Delete an existing index from your organization. Index deletions are permanent and cannot be reverted.
+    /// You cannot recreate an index with the same name as deleted ones.
+    pub async fn delete_logs_index(
+        &self,
+        name: String,
+    ) -> Result<crate::datadogV1::model::LogsIndex, datadog::Error<DeleteLogsIndexError>> {
+        match self.delete_logs_index_with_http_info(name).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),
+        }
+    }
+
+    /// Delete an existing index from your organization. Index deletions are permanent and cannot be reverted.
+    /// You cannot recreate an index with the same name as deleted ones.
+    pub async fn delete_logs_index_with_http_info(
+        &self,
+        name: String,
+    ) -> Result<
+        datadog::ResponseContent<crate::datadogV1::model::LogsIndex>,
+        datadog::Error<DeleteLogsIndexError>,
+    > {
+        let local_configuration = &self.config;
+        let operation_id = "v1.delete_logs_index";
+
+        let local_client = &self.client;
+
+        let local_uri_str = format!(
+            "{}/api/v1/logs/config/indexes/{name}",
+            local_configuration.get_operation_host(operation_id),
+            name = datadog::urlencode(name)
+        );
+        let mut local_req_builder =
+            local_client.request(reqwest::Method::DELETE, local_uri_str.as_str());
+
+        // build headers
+        let mut headers = HeaderMap::new();
+        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"),
+            );
+        };
+
+        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::datadogV1::model::LogsIndex>(&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<DeleteLogsIndexError> =
+                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))
+        }
+    }
+
     /// Get one log index from your organization. This endpoint takes no JSON arguments.
     pub async fn get_logs_index(
         &self,
diff --git a/tests/scenarios/features/v1/logs_indexes.feature b/tests/scenarios/features/v1/logs_indexes.feature
@@ -22,6 +22,20 @@ Feature: Logs Indexes
     When the request is sent
     Then the response status is 200 OK
 
+  @generated @skip @team:DataDog/logs-backend @team:DataDog/logs-core
+  Scenario: Delete an index returns "Not Found" response
+    Given new "DeleteLogsIndex" request
+    And request contains "name" parameter from "REPLACE.ME"
+    When the request is sent
+    Then the response status is 404 Not Found
+
+  @generated @skip @team:DataDog/logs-backend @team:DataDog/logs-core
+  Scenario: Delete an index returns "OK" response
+    Given new "DeleteLogsIndex" request
+    And request contains "name" parameter from "REPLACE.ME"
+    When the request is sent
+    Then the response status is 200 OK
+
   @generated @skip @team:DataDog/logs-backend @team:DataDog/logs-core
   Scenario: Get all indexes returns "OK" response
     Given new "ListLogIndexes" request
diff --git a/tests/scenarios/features/v1/undo.json b/tests/scenarios/features/v1/undo.json
@@ -694,6 +694,12 @@
       "type": "unsafe"
     }
   },
+  "DeleteLogsIndex": {
+    "tag": "Logs Indexes",
+    "undo": {
+      "type": "idempotent"
+    }
+  },
   "GetLogsIndex": {
     "tag": "Logs Indexes",
     "undo": {
diff --git a/tests/scenarios/function_mappings.rs b/tests/scenarios/function_mappings.rs
@@ -1330,6 +1330,9 @@ pub fn collect_function_calls(world: &mut DatadogWorld) {
     world
         .function_mappings
         .insert("v1.CreateLogsIndex".into(), test_v1_create_logs_index);
+    world
+        .function_mappings
+        .insert("v1.DeleteLogsIndex".into(), test_v1_delete_logs_index);
     world
         .function_mappings
         .insert("v1.GetLogsIndex".into(), test_v1_get_logs_index);
@@ -7590,6 +7593,31 @@ fn test_v1_create_logs_index(world: &mut DatadogWorld, _parameters: &HashMap<Str
     world.response.code = response.status.as_u16();
 }
 
+fn test_v1_delete_logs_index(world: &mut DatadogWorld, _parameters: &HashMap<String, Value>) {
+    let api = world
+        .api_instances
+        .v1_api_logs_indexes
+        .as_ref()
+        .expect("api instance not found");
+    let name = serde_json::from_value(_parameters.get("name").unwrap().clone()).unwrap();
+    let response = match block_on(api.delete_logs_index_with_http_info(name)) {
+        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}"),
+            };
+        }
+    };
+    world.response.object = serde_json::to_value(response.entity).unwrap();
+    world.response.code = response.status.as_u16();
+}
+
 fn test_v1_get_logs_index(world: &mut DatadogWorld, _parameters: &HashMap<String, Value>) {
     let api = world
         .api_instances

Original file line number	Diff line number	Diff line change
`@@ -4,13 +4,13 @@`
`4`	`4`	`"spec_versions": {`
`5`	`5`	`"v1": {`
`6`	`6`	`"apigentools_version": "1.6.6",`
`7`		`- "regenerated": "2025-03-05 14:38:20.340456",`
`8`		`- "spec_repo_commit": "0c376cca"`
	`7`	`+ "regenerated": "2025-03-05 18:01:21.100831",`
	`8`	`+ "spec_repo_commit": "5f4072eb"`
`9`	`9`	`},`
`10`	`10`	`"v2": {`
`11`	`11`	`"apigentools_version": "1.6.6",`
`12`		`- "regenerated": "2025-03-05 14:38:20.356470",`
`13`		`- "spec_repo_commit": "0c376cca"`
	`12`	`+ "regenerated": "2025-03-05 18:01:21.116060",`
	`13`	`+ "spec_repo_commit": "5f4072eb"`
`14`	`14`	`}`
`15`	`15`	`}`
`16`	`16`	`}`