Add OpenAPI specs for 52 unstable incident-app endpoints

examples/v2_incidents_BatchCreateIncidentRuleExecutionStates.rs

@@ -0,0 +1,40 @@
+// Batch create incident rule execution states returns "Created" response
+use chrono::{DateTime, Utc};
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_incidents::IncidentsAPI;
+use datadog_api_client::datadogV2::model::IncidentBatchCreateRuleExecutionStatesData;
+use datadog_api_client::datadogV2::model::IncidentBatchCreateRuleExecutionStatesDataAttributes;
+use datadog_api_client::datadogV2::model::IncidentBatchCreateRuleExecutionStatesRequest;
+use datadog_api_client::datadogV2::model::IncidentRuleExecutionStateRule;
+use datadog_api_client::datadogV2::model::IncidentRuleExecutionStateType;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() {
+    let body = IncidentBatchCreateRuleExecutionStatesRequest::new(
+        IncidentBatchCreateRuleExecutionStatesData::new(
+            IncidentBatchCreateRuleExecutionStatesDataAttributes::new(vec![
+                IncidentRuleExecutionStateRule::new(
+                    Uuid::parse_str("00000000-0000-0000-0000-000000000000").expect("invalid UUID"),
+                )
+                .last_executed_at(Some(
+                    DateTime::parse_from_rfc3339("2024-01-01T00:00:00+00:00")
+                        .expect("Failed to parse datetime")
+                        .with_timezone(&Utc),
+                )),
+            ]),
+            IncidentRuleExecutionStateType::INCIDENT_RULE_EXECUTION_STATES,
+        ),
+    );
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.BatchCreateIncidentRuleExecutionStates", true);
+    let api = IncidentsAPI::with_config(configuration);
+    let resp = api
+        .batch_create_incident_rule_execution_states("incident_id".to_string(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_incidents_BatchUpdateIncidentRuleExecutionStates.rs

@@ -0,0 +1,40 @@
+// Batch update incident rule execution states returns "OK" response
+use chrono::{DateTime, Utc};
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_incidents::IncidentsAPI;
+use datadog_api_client::datadogV2::model::IncidentBatchUpdateRuleExecutionStatesData;
+use datadog_api_client::datadogV2::model::IncidentBatchUpdateRuleExecutionStatesDataAttributes;
+use datadog_api_client::datadogV2::model::IncidentBatchUpdateRuleExecutionStatesRequest;
+use datadog_api_client::datadogV2::model::IncidentRuleExecutionStateRule;
+use datadog_api_client::datadogV2::model::IncidentRuleExecutionStateType;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() {
+    let body = IncidentBatchUpdateRuleExecutionStatesRequest::new(
+        IncidentBatchUpdateRuleExecutionStatesData::new(
+            IncidentBatchUpdateRuleExecutionStatesDataAttributes::new(vec![
+                IncidentRuleExecutionStateRule::new(
+                    Uuid::parse_str("00000000-0000-0000-0000-000000000000").expect("invalid UUID"),
+                )
+                .last_executed_at(Some(
+                    DateTime::parse_from_rfc3339("2024-01-01T00:00:00+00:00")
+                        .expect("Failed to parse datetime")
+                        .with_timezone(&Utc),
+                )),
+            ]),
+            IncidentRuleExecutionStateType::INCIDENT_RULE_EXECUTION_STATES,
+        ),
+    );
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.BatchUpdateIncidentRuleExecutionStates", true);
+    let api = IncidentsAPI::with_config(configuration);
+    let resp = api
+        .batch_update_incident_rule_execution_states("incident_id".to_string(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_incidents_CreateIncidentCommunication.rs

@@ -0,0 +1,42 @@
+// Create an incident communication returns "Created" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_incidents::IncidentsAPI;
+use datadog_api_client::datadogV2::model::IncidentCommunicationContent;
+use datadog_api_client::datadogV2::model::IncidentCommunicationContentHandle;
+use datadog_api_client::datadogV2::model::IncidentCommunicationDataAttributesRequest;
+use datadog_api_client::datadogV2::model::IncidentCommunicationDataRequest;
+use datadog_api_client::datadogV2::model::IncidentCommunicationKind;
+use datadog_api_client::datadogV2::model::IncidentCommunicationRequest;
+use datadog_api_client::datadogV2::model::IncidentCommunicationType;
+
+#[tokio::main]
+async fn main() {
+    let body = IncidentCommunicationRequest::new(IncidentCommunicationDataRequest::new(
+        IncidentCommunicationDataAttributesRequest::new(
+            IncidentCommunicationKind::MANUAL,
+            IncidentCommunicationContent::new(
+                vec![IncidentCommunicationContentHandle::new(
+                    "@slack-incidents-channel".to_string(),
+                )
+                .created_at("2024-01-01T00:00:00.000Z".to_string())
+                .display_name("#incidents-channel".to_string())],
+                "Incident update for INC-123.".to_string(),
+            )
+            .grouping_key("update-1".to_string())
+            .status(0)
+            .subject("Incident INC-123: Update".to_string()),
+        ),
+        IncidentCommunicationType::COMMUNICATION,
+    ));
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.CreateIncidentCommunication", true);
+    let api = IncidentsAPI::with_config(configuration);
+    let resp = api
+        .create_incident_communication("incident_id".to_string(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_incidents_CreateIncidentGoogleMeetSpace.rs

@@ -0,0 +1,18 @@
+// Create an incident Google Meet space returns "Created" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_incidents::IncidentsAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.CreateIncidentGoogleMeetSpace", true);
+    let api = IncidentsAPI::with_config(configuration);
+    let resp = api
+        .create_incident_google_meet_space("incident_id".to_string())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_incidents_CreateIncidentJiraIssue.rs

@@ -0,0 +1,34 @@
+// Create an incident Jira issue returns "Created" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_incidents::IncidentsAPI;
+use datadog_api_client::datadogV2::model::IncidentJiraIssueDataAttributesRequest;
+use datadog_api_client::datadogV2::model::IncidentJiraIssueDataRequest;
+use datadog_api_client::datadogV2::model::IncidentJiraIssueRequest;
+use datadog_api_client::datadogV2::model::IncidentJiraIssueType;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() {
+    let body = IncidentJiraIssueRequest::new(IncidentJiraIssueDataRequest::new(
+        IncidentJiraIssueDataAttributesRequest::new(
+            "123456".to_string(),
+            "10001".to_string(),
+            "10000".to_string(),
+        )
+        .template_id(
+            Uuid::parse_str("00000000-0000-0000-0000-000000000000").expect("invalid UUID"),
+        ),
+        IncidentJiraIssueType::INCIDENT_JIRA_ISSUES,
+    ));
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.CreateIncidentJiraIssue", true);
+    let api = IncidentsAPI::with_config(configuration);
+    let resp = api
+        .create_incident_jira_issue("incident_id".to_string(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_incidents_CreateIncidentJiraTemplate.rs

@@ -0,0 +1,54 @@
+// Create an incident Jira template returns "Created" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_incidents::IncidentsAPI;
+use datadog_api_client::datadogV2::model::IncidentJiraTemplateDataAttributesRequest;
+use datadog_api_client::datadogV2::model::IncidentJiraTemplateDataRequest;
+use datadog_api_client::datadogV2::model::IncidentJiraTemplateFieldConfiguration;
+use datadog_api_client::datadogV2::model::IncidentJiraTemplateIncidentTypeRelationship;
+use datadog_api_client::datadogV2::model::IncidentJiraTemplateIncidentTypeRelationshipData;
+use datadog_api_client::datadogV2::model::IncidentJiraTemplateRelationships;
+use datadog_api_client::datadogV2::model::IncidentJiraTemplateRequest;
+use datadog_api_client::datadogV2::model::IncidentJiraTemplateType;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() {
+    let body = IncidentJiraTemplateRequest::new(
+        IncidentJiraTemplateDataRequest::new(
+            IncidentJiraTemplateDataAttributesRequest::new(
+                "123456".to_string(),
+                "10001".to_string(),
+                "10000".to_string(),
+                "INC".to_string(),
+            )
+            .field_configurations(vec![IncidentJiraTemplateFieldConfiguration::new(
+                "summary".to_string(),
+                "bidirectional".to_string(),
+            )
+            .incident_field(Some("title".to_string()))
+            .jira_field_type(Some("string".to_string()))])
+            .is_default(false)
+            .name("Default Jira Template".to_string())
+            .sync_enabled(true)
+            .type_("jira".to_string()),
+            IncidentJiraTemplateType::INCIDENTS_JIRA_TEMPLATES,
+        )
+        .relationships(IncidentJiraTemplateRelationships::new().incident_type(
+            IncidentJiraTemplateIncidentTypeRelationship::new(
+                IncidentJiraTemplateIncidentTypeRelationshipData::new(
+                    Uuid::parse_str("00000000-0000-0000-0000-000000000000").expect("invalid UUID"),
+                    "incident_types".to_string(),
+                ),
+            ),
+        )),
+    );
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.CreateIncidentJiraTemplate", true);
+    let api = IncidentsAPI::with_config(configuration);
+    let resp = api.create_incident_jira_template(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_incidents_CreateIncidentMSTeamsOnlineMeeting.rs

@@ -0,0 +1,18 @@
+// Create an incident Microsoft Teams online meeting returns "Created" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_incidents::IncidentsAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.CreateIncidentMSTeamsOnlineMeeting", true);
+    let api = IncidentsAPI::with_config(configuration);
+    let resp = api
+        .create_incident_ms_teams_online_meeting("incident_id".to_string())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_incidents_CreateIncidentMicrosoftTeamsConfiguration.rs

@@ -0,0 +1,35 @@
+// Create an incident Microsoft Teams configuration returns "Created" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_incidents::CreateIncidentMicrosoftTeamsConfigurationOptionalParams;
+use datadog_api_client::datadogV2::api_incidents::IncidentsAPI;
+use datadog_api_client::datadogV2::model::IncidentMicrosoftTeamsConfigurationDataAttributesRequest;
+use datadog_api_client::datadogV2::model::IncidentMicrosoftTeamsConfigurationDataRequest;
+use datadog_api_client::datadogV2::model::IncidentMicrosoftTeamsConfigurationRequest;
+use datadog_api_client::datadogV2::model::IncidentMicrosoftTeamsConfigurationType;
+
+#[tokio::main]
+async fn main() {
+    let body = IncidentMicrosoftTeamsConfigurationRequest::new(
+        IncidentMicrosoftTeamsConfigurationDataRequest::new(
+            IncidentMicrosoftTeamsConfigurationDataAttributesRequest::new()
+                .manual_meeting_creation(false)
+                .post_meeting_summary(true),
+            IncidentMicrosoftTeamsConfigurationType::MICROSOFT_TEAMS_CONFIGURATIONS,
+        ),
+    );
+    let mut configuration = datadog::Configuration::new();
+    configuration
+        .set_unstable_operation_enabled("v2.CreateIncidentMicrosoftTeamsConfiguration", true);
+    let api = IncidentsAPI::with_config(configuration);
+    let resp = api
+        .create_incident_microsoft_teams_configuration(
+            body,
+            CreateIncidentMicrosoftTeamsConfigurationOptionalParams::default(),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_incidents_CreateIncidentRoleAssignment.rs

@@ -0,0 +1,55 @@
+// Create an incident role assignment returns "Created" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_incidents::IncidentsAPI;
+use datadog_api_client::datadogV2::model::IncidentRoleAssignmentDataAttributesRequest;
+use datadog_api_client::datadogV2::model::IncidentRoleAssignmentDataRequest;
+use datadog_api_client::datadogV2::model::IncidentRoleAssignmentRelationshipsRequest;
+use datadog_api_client::datadogV2::model::IncidentRoleAssignmentRequest;
+use datadog_api_client::datadogV2::model::IncidentRoleAssignmentResponderRelationship;
+use datadog_api_client::datadogV2::model::IncidentRoleAssignmentResponderRelationshipData;
+use datadog_api_client::datadogV2::model::IncidentRoleAssignmentRoleRelationship;
+use datadog_api_client::datadogV2::model::IncidentRoleAssignmentRoleRelationshipData;
+use datadog_api_client::datadogV2::model::IncidentRoleAssignmentType;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() {
+    let body = IncidentRoleAssignmentRequest::new(
+        IncidentRoleAssignmentDataRequest::new(
+            IncidentRoleAssignmentRelationshipsRequest::new(
+                IncidentRoleAssignmentResponderRelationship::new(
+                    IncidentRoleAssignmentResponderRelationshipData::new(
+                        Uuid::parse_str("00000000-0000-0000-0000-000000000000")
+                            .expect("invalid UUID"),
+                        "users".to_string(),
+                    ),
+                ),
+            )
+            .reserved_role(IncidentRoleAssignmentRoleRelationship::new().data(
+                IncidentRoleAssignmentRoleRelationshipData::new(
+                    Uuid::parse_str("00000000-0000-0000-0000-000000000000").expect("invalid UUID"),
+                    "incident_reserved_roles".to_string(),
+                ),
+            ))
+            .user_defined_role(IncidentRoleAssignmentRoleRelationship::new().data(
+                IncidentRoleAssignmentRoleRelationshipData::new(
+                    Uuid::parse_str("00000000-0000-0000-0000-000000000000").expect("invalid UUID"),
+                    "incident_reserved_roles".to_string(),
+                ),
+            )),
+            IncidentRoleAssignmentType::INCIDENT_ROLE_ASSIGNMENTS,
+        )
+        .attributes(
+            IncidentRoleAssignmentDataAttributesRequest::new().role(Some("commander".to_string())),
+        ),
+    );
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.CreateIncidentRoleAssignment", true);
+    let api = IncidentsAPI::with_config(configuration);
+    let resp = api.create_incident_role_assignment(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_incidents_CreateIncidentStatusPageNotice.rs

@@ -0,0 +1,41 @@
+// Publish an incident status page notice returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_incidents::CreateIncidentStatusPageNoticeOptionalParams;
+use datadog_api_client::datadogV2::api_incidents::IncidentsAPI;
+use datadog_api_client::datadogV2::model::IncidentStatusPageNoticeCreateData;
+use datadog_api_client::datadogV2::model::IncidentStatusPageNoticeCreateDataAttributes;
+use datadog_api_client::datadogV2::model::IncidentStatusPageNoticeCreateRequest;
+use datadog_api_client::datadogV2::model::IncidentStatusPageNoticeIntegrationType;
+use std::collections::BTreeMap;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() {
+    let body = IncidentStatusPageNoticeCreateRequest::new(IncidentStatusPageNoticeCreateData::new(
+        IncidentStatusPageNoticeCreateDataAttributes::new()
+            .components(BTreeMap::from([(
+                "component_1".to_string(),
+                "degraded_performance".to_string(),
+            )]))
+            .message("We are investigating reports of elevated error rates.".to_string())
+            .status("investigating".to_string())
+            .title("Service degradation detected.".to_string()),
+        IncidentStatusPageNoticeIntegrationType::INCIDENT_INTEGRATIONS,
+    ));
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.CreateIncidentStatusPageNotice", true);
+    let api = IncidentsAPI::with_config(configuration);
+    let resp = api
+        .create_incident_status_page_notice(
+            "incident_id".to_string(),
+            Uuid::parse_str("00000000-0000-0000-0000-000000000000").expect("invalid UUID"),
+            body,
+            CreateIncidentStatusPageNoticeOptionalParams::default(),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}