From da97b55615e8f23034a22ea4d8f26ad1724c7801 Mon Sep 17 00:00:00 2001 From: "ci.datadog-api-spec" Date: Mon, 9 Nov 2026 19:26:24 +0000 Subject: [PATCH] Regenerate client from commit f2376af of spec repo --- Cargo.lock | 2 +- Cargo.toml | 2 +- src/client.rs | 26 +-- src/generated/mod.rs | 5 + src/generated/security/findings.rs | 354 +++++++++++++++++++++++++++++ src/generated/security/mod.rs | 14 ++ src/generated/surface.txt | 14 ++ src/generated/writes.rs | 12 + 8 files changed, 402 insertions(+), 27 deletions(-) create mode 100644 src/generated/security/findings.rs create mode 100644 src/generated/security/mod.rs diff --git a/Cargo.lock b/Cargo.lock index c07302dd..02c6131e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1100,7 +1100,7 @@ checksum = "a4ae5f15dda3c708c0ade84bfee31ccab44a3da4f88015ed22f63732abe300c8" [[package]] name = "datadog-api-client" version = "0.38.0" -source = "git+https://github.com/DataDog/datadog-api-client-rust?rev=a0148e35b714615060937e8ebde2711fe9906aae#a0148e35b714615060937e8ebde2711fe9906aae" +source = "git+https://github.com/DataDog/datadog-api-client-rust?rev=fe48cf206fb2bbfd89e447194e2753ae72f943bd#fe48cf206fb2bbfd89e447194e2753ae72f943bd" dependencies = [ "async-stream", "chrono", diff --git a/Cargo.toml b/Cargo.toml index 7f508d68..5ea32b03 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -136,7 +136,7 @@ zip = { version = "9", default-features = false, features = ["deflate"], optiona # Datadog API client — pinned to a git rev # Use default-features = false; feature sets are activated per-target via features above -datadog-api-client = { git = "https://github.com/DataDog/datadog-api-client-rust", rev = "a0148e35b714615060937e8ebde2711fe9906aae", optional = true, default-features = false } +datadog-api-client = { git = "https://github.com/DataDog/datadog-api-client-rust", rev = "fe48cf206fb2bbfd89e447194e2753ae72f943bd", optional = true, default-features = false } # HTTP middleware (version-matched to DD client; compiles on all targets) reqwest-middleware = "0.5" diff --git a/src/client.rs b/src/client.rs index bded7a55..63459392 100644 --- a/src/client.rs +++ b/src/client.rs @@ -418,30 +418,6 @@ static UNSTABLE_OPS: &[&str] = &[ "v2.star_model_lab_project", "v2.unpin_model_lab_run", "v2.unstar_model_lab_project", - // Databricks Integration (5) - "v2.create_databricks_integration_account", - "v2.delete_databricks_integration_account", - "v2.get_databricks_integration_account", - "v2.list_databricks_integration_accounts", - "v2.update_databricks_integration_account", - // Elastic Cloud Integration (5) - "v2.create_elastic_cloud_integration_account", - "v2.delete_elastic_cloud_integration_account", - "v2.get_elastic_cloud_integration_account", - "v2.list_elastic_cloud_integration_accounts", - "v2.update_elastic_cloud_integration_account", - // Snowflake Integration (5) - "v2.create_snowflake_integration_account", - "v2.delete_snowflake_integration_account", - "v2.get_snowflake_integration_account", - "v2.list_snowflake_integration_accounts", - "v2.update_snowflake_integration_account", - // Twilio Integration (5) - "v2.create_twilio_integration_account", - "v2.delete_twilio_integration_account", - "v2.get_twilio_integration_account", - "v2.list_twilio_integration_accounts", - "v2.update_twilio_integration_account", ]; #[cfg(test)] @@ -563,7 +539,7 @@ mod tests { #[test] fn test_unstable_ops_count() { - assert_eq!(UNSTABLE_OPS.len(), 207); + assert_eq!(UNSTABLE_OPS.len(), 187); } #[test] diff --git a/src/generated/mod.rs b/src/generated/mod.rs index ba771ea5..7dca2847 100644 --- a/src/generated/mod.rs +++ b/src/generated/mod.rs @@ -1,8 +1,13 @@ // Code generated by openapi-transformer. DO NOT EDIT. +// pup CI denies clippy warnings, and the spec's size, not the generator, drives these two: +// operations with many params make long handler signatures and large command variants. +#![allow(clippy::too_many_arguments, clippy::large_enum_variant)] + pub mod authn_mappings; pub mod domain_allowlist; pub mod downtime; +pub mod security; pub mod writes; use anyhow::Result; diff --git a/src/generated/security/findings.rs b/src/generated/security/findings.rs new file mode 100644 index 00000000..a6ea5c76 --- /dev/null +++ b/src/generated/security/findings.rs @@ -0,0 +1,354 @@ +// Code generated by openapi-transformer. DO NOT EDIT. + +use anyhow::Result; +use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI; +use datadog_api_client::datadogV2::model::{ + AssigneeRequest, AttachCaseRequest, AttachJiraIssueRequest, AttachLinearIssueRequest, + AttachServiceNowTicketRequest, CreateCaseRequestArray, CreateJiraIssueRequestArray, + CreateLinearIssueRequestArray, CreateServiceNowTicketRequestArray, DetachCaseRequest, + MuteFindingsRequest, SeverityOverrideRequest, +}; + +use crate::config::Config; +use crate::formatter; +use crate::util; + +#[derive(clap::Subcommand)] +pub enum Command { + /// Attach security findings to a case + /// + /// Attach security findings to a case. + /// You can attach up to 50 security findings per case. Security findings that are already attached to another case will be detached from their previous case and attached to the specified case. + AttachCase { + /// Unique identifier of the case to attach security findings to + case_id: String, + #[arg(long = "file")] + file: String, + }, + /// Attach security findings to a Jira issue + /// + /// Attach security findings to a Jira issue by providing the Jira issue URL. + /// You can attach up to 50 security findings per Jira issue. If the Jira issue is not linked to any case, this operation will create a case for the security findings and link the Jira issue to the newly created case. To configure the Jira integration, see [Bidirectional ticket syncing with Jira](https://docs.datadoghq.com/security/ticketing_integrations/#bidirectional-ticket-syncing-with-jira). Security findings that are already attached to another Jira issue will be detached from their previous Jira issue and attached to the specified Jira issue. + AttachJiraIssue { + #[arg(long = "file")] + file: String, + }, + /// Attach security findings to a Linear issue + /// + /// Attach security findings to a Linear issue by providing the Linear issue URL. + /// You can attach up to 50 security findings per Linear issue. If the Linear issue is not linked to any case, this operation will create a case for the security findings and link the Linear issue to the newly created case. Security findings that are already attached to another Linear issue will be detached from their previous Linear issue and attached to the specified Linear issue. + AttachLinearIssue { + #[arg(long = "file")] + file: String, + }, + /// Attach security findings to a ServiceNow ticket + /// + /// Attach security findings to a ServiceNow ticket by providing the ServiceNow ticket URL. + /// You can attach up to 50 security findings per ServiceNow ticket. If the ServiceNow ticket is not linked to any case, this operation will create a case for the security findings and link the ServiceNow ticket to the newly created case. Security findings that are already attached to another ServiceNow ticket will be detached from their previous ServiceNow ticket and attached to the specified ServiceNow ticket. + AttachServicenowTicket { + #[arg(long = "file")] + file: String, + }, + /// Create cases for security findings + /// + /// Create cases for security findings. + /// You can create up to 50 cases per request and associate up to 50 security findings per case. Security findings that are already attached to another case will be detached from their previous case and attached to the newly created case. + CreateCases { + #[arg(long = "file")] + file: String, + }, + /// Create Jira issues for security findings + /// + /// Create Jira issues for security findings. + /// This operation creates a case in Datadog and a Jira issue linked to that case for bidirectional sync between Datadog and Jira. To configure the Jira integration, see [Bidirectional ticket syncing with Jira](https://docs.datadoghq.com/security/ticketing_integrations/#bidirectional-ticket-syncing-with-jira). You can create up to 50 Jira issues per request and associate up to 50 security findings per Jira issue. Security findings that are already attached to another Jira issue will be detached from their previous Jira issue and attached to the newly created Jira issue. + CreateJiraIssues { + #[arg(long = "file")] + file: String, + }, + /// Create Linear issues for security findings + /// + /// Create Linear issues for security findings. + /// This operation creates a case in Datadog and a Linear issue linked to that case for bidirectional sync between Datadog and Linear. You can create up to 50 Linear issues per request and associate up to 50 security findings per Linear issue. Security findings that are already attached to another Linear issue will be detached from their previous Linear issue and attached to the newly created Linear issue. + CreateLinearIssues { + #[arg(long = "file")] + file: String, + }, + /// Create ServiceNow tickets for security findings + /// + /// Create ServiceNow tickets for security findings. + /// This operation creates a case in Datadog and a ServiceNow ticket linked to that case for bidirectional sync between Datadog and ServiceNow. You can create up to 50 ServiceNow tickets per request and associate up to 50 security findings per ServiceNow ticket. Security findings that are already attached to another ServiceNow ticket will be detached from their previous ServiceNow ticket and attached to the newly created ServiceNow ticket. + CreateServicenowTickets { + #[arg(long = "file")] + file: String, + }, + /// Detach security findings from their case + /// + /// Detach security findings from their case. + /// This operation dissociates security findings from their associated cases without deleting the cases themselves. You can detach security findings from multiple different cases in a single request, with a limit of 50 security findings per request. Security findings that are not currently attached to any case will be ignored. + DetachCase { + #[arg(long = "file")] + file: String, + }, + /// Mute or unmute security findings + /// + /// Mute or unmute security findings. + /// You can mute or unmute up to 100 security findings per request. The request body must include `is_muted` and `reason` attributes. The allowed reasons depend on whether the finding is being muted or unmuted: + /// - To mute a finding: `PENDING_FIX`, `FALSE_POSITIVE`, `OTHER`, `NO_FIX`, `DUPLICATE`, `RISK_ACCEPTED`. + /// - To unmute a finding: `NO_PENDING_FIX`, `HUMAN_ERROR`, `NO_LONGER_ACCEPTED_RISK`, `OTHER`. + Mute { + #[arg(long = "file")] + file: String, + }, + /// Assign or unassign security findings + /// + /// Assign or unassign security findings. + /// You can assign up to 100 security findings per request. Set `assignee_id` to the unique identifier of the Datadog user you want to assign the findings to. Omit `assignee_id` (or set it to `null`) to unassign the findings. Per-finding warnings and failures are returned in the response `meta` object. + Assign { + #[arg(long = "file")] + file: String, + }, + /// Override the severity of security findings + /// + /// Set or clear the manual severity override of security findings. + /// + /// You can update up to 100 security findings per request. + /// Use the `set` action with a `value` to apply a manual severity override. + /// `value` is required for `set` and must be omitted for `clear`. + /// The `info` value sets the lowest severity the finding type allows. + /// Use the `clear` action to remove a manual severity override. + /// `clear` does not remove a severity set by an automation rule. + /// The optional `description` is accepted with both actions and has a limit of 280 characters. + /// + /// Auto-closed findings are excluded. + /// Findings whose severity was set by an automation rule are skipped and listed in the response `meta.warnings`. + /// If every finding is skipped this way, the request fails with a `400` error. + /// Findings that cannot be found are skipped without a warning. + /// The request fails with a `404` error only if none of the findings can be found. + OverrideSeverity { + #[arg(long = "file")] + file: String, + }, +} + +pub async fn run(cfg: &Config, command: Command) -> Result<()> { + match command { + Command::AttachCase { case_id, file } => attach_case(cfg, case_id, &file).await, + Command::AttachJiraIssue { file } => attach_jira_issue(cfg, &file).await, + Command::AttachLinearIssue { file } => attach_linear_issue(cfg, &file).await, + Command::AttachServicenowTicket { file } => attach_servicenow_ticket(cfg, &file).await, + Command::CreateCases { file } => create_cases(cfg, &file).await, + Command::CreateJiraIssues { file } => create_jira_issues(cfg, &file).await, + Command::CreateLinearIssues { file } => create_linear_issues(cfg, &file).await, + Command::CreateServicenowTickets { file } => create_servicenow_tickets(cfg, &file).await, + Command::DetachCase { file } => detach_case(cfg, &file).await, + Command::Mute { file } => mute(cfg, &file).await, + Command::Assign { file } => assign(cfg, &file).await, + Command::OverrideSeverity { file } => override_severity(cfg, &file).await, + } +} + +/// Attach security findings to a case +/// +/// Attach security findings to a case. +/// You can attach up to 50 security findings per case. Security findings that are already attached to another case will be detached from their previous case and attached to the specified case. +pub async fn attach_case(cfg: &Config, case_id: String, file: &str) -> Result<()> { + let body: AttachCaseRequest = util::read_json_file(file)?; + let api = crate::make_api!(SecurityMonitoringAPI, cfg); + let resp = api + .attach_case(case_id, body) + .await + .map_err(|e| anyhow::anyhow!("failed to attach_case: {:?}", e))?; + formatter::output(cfg, &resp) +} + +/// Attach security findings to a Jira issue +/// +/// Attach security findings to a Jira issue by providing the Jira issue URL. +/// You can attach up to 50 security findings per Jira issue. If the Jira issue is not linked to any case, this operation will create a case for the security findings and link the Jira issue to the newly created case. To configure the Jira integration, see [Bidirectional ticket syncing with Jira](https://docs.datadoghq.com/security/ticketing_integrations/#bidirectional-ticket-syncing-with-jira). Security findings that are already attached to another Jira issue will be detached from their previous Jira issue and attached to the specified Jira issue. +pub async fn attach_jira_issue(cfg: &Config, file: &str) -> Result<()> { + let body: AttachJiraIssueRequest = util::read_json_file(file)?; + let api = crate::make_api!(SecurityMonitoringAPI, cfg); + let resp = api + .attach_jira_issue(body) + .await + .map_err(|e| anyhow::anyhow!("failed to attach_jira_issue: {:?}", e))?; + formatter::output(cfg, &resp) +} + +/// Attach security findings to a Linear issue +/// +/// Attach security findings to a Linear issue by providing the Linear issue URL. +/// You can attach up to 50 security findings per Linear issue. If the Linear issue is not linked to any case, this operation will create a case for the security findings and link the Linear issue to the newly created case. Security findings that are already attached to another Linear issue will be detached from their previous Linear issue and attached to the specified Linear issue. +pub async fn attach_linear_issue(cfg: &Config, file: &str) -> Result<()> { + let body: AttachLinearIssueRequest = util::read_json_file(file)?; + let api = crate::make_api!(SecurityMonitoringAPI, cfg); + let resp = api + .attach_linear_issue(body) + .await + .map_err(|e| anyhow::anyhow!("failed to attach_linear_issue: {:?}", e))?; + formatter::output(cfg, &resp) +} + +/// Attach security findings to a ServiceNow ticket +/// +/// Attach security findings to a ServiceNow ticket by providing the ServiceNow ticket URL. +/// You can attach up to 50 security findings per ServiceNow ticket. If the ServiceNow ticket is not linked to any case, this operation will create a case for the security findings and link the ServiceNow ticket to the newly created case. Security findings that are already attached to another ServiceNow ticket will be detached from their previous ServiceNow ticket and attached to the specified ServiceNow ticket. +pub async fn attach_servicenow_ticket(cfg: &Config, file: &str) -> Result<()> { + let body: AttachServiceNowTicketRequest = util::read_json_file(file)?; + let api = crate::make_api!(SecurityMonitoringAPI, cfg); + let resp = api + .attach_service_now_ticket(body) + .await + .map_err(|e| anyhow::anyhow!("failed to attach_service_now_ticket: {:?}", e))?; + formatter::output(cfg, &resp) +} + +/// Create cases for security findings +/// +/// Create cases for security findings. +/// You can create up to 50 cases per request and associate up to 50 security findings per case. Security findings that are already attached to another case will be detached from their previous case and attached to the newly created case. +pub async fn create_cases(cfg: &Config, file: &str) -> Result<()> { + let body: CreateCaseRequestArray = util::read_json_file(file)?; + let api = crate::make_api!(SecurityMonitoringAPI, cfg); + let resp = api + .create_cases(body) + .await + .map_err(|e| anyhow::anyhow!("failed to create_cases: {:?}", e))?; + let count = resp.data.len(); + let meta = formatter::Metadata { + count: Some(count), + command: Some("security findings create-cases".to_string()), + ..Default::default() + }; + formatter::output_with_meta(cfg, &resp, &meta) +} + +/// Create Jira issues for security findings +/// +/// Create Jira issues for security findings. +/// This operation creates a case in Datadog and a Jira issue linked to that case for bidirectional sync between Datadog and Jira. To configure the Jira integration, see [Bidirectional ticket syncing with Jira](https://docs.datadoghq.com/security/ticketing_integrations/#bidirectional-ticket-syncing-with-jira). You can create up to 50 Jira issues per request and associate up to 50 security findings per Jira issue. Security findings that are already attached to another Jira issue will be detached from their previous Jira issue and attached to the newly created Jira issue. +pub async fn create_jira_issues(cfg: &Config, file: &str) -> Result<()> { + let body: CreateJiraIssueRequestArray = util::read_json_file(file)?; + let api = crate::make_api!(SecurityMonitoringAPI, cfg); + let resp = api + .create_jira_issues(body) + .await + .map_err(|e| anyhow::anyhow!("failed to create_jira_issues: {:?}", e))?; + let count = resp.data.len(); + let meta = formatter::Metadata { + count: Some(count), + command: Some("security findings create-jira-issues".to_string()), + ..Default::default() + }; + formatter::output_with_meta(cfg, &resp, &meta) +} + +/// Create Linear issues for security findings +/// +/// Create Linear issues for security findings. +/// This operation creates a case in Datadog and a Linear issue linked to that case for bidirectional sync between Datadog and Linear. You can create up to 50 Linear issues per request and associate up to 50 security findings per Linear issue. Security findings that are already attached to another Linear issue will be detached from their previous Linear issue and attached to the newly created Linear issue. +pub async fn create_linear_issues(cfg: &Config, file: &str) -> Result<()> { + let body: CreateLinearIssueRequestArray = util::read_json_file(file)?; + let api = crate::make_api!(SecurityMonitoringAPI, cfg); + let resp = api + .create_linear_issues(body) + .await + .map_err(|e| anyhow::anyhow!("failed to create_linear_issues: {:?}", e))?; + let count = resp.data.len(); + let meta = formatter::Metadata { + count: Some(count), + command: Some("security findings create-linear-issues".to_string()), + ..Default::default() + }; + formatter::output_with_meta(cfg, &resp, &meta) +} + +/// Create ServiceNow tickets for security findings +/// +/// Create ServiceNow tickets for security findings. +/// This operation creates a case in Datadog and a ServiceNow ticket linked to that case for bidirectional sync between Datadog and ServiceNow. You can create up to 50 ServiceNow tickets per request and associate up to 50 security findings per ServiceNow ticket. Security findings that are already attached to another ServiceNow ticket will be detached from their previous ServiceNow ticket and attached to the newly created ServiceNow ticket. +pub async fn create_servicenow_tickets(cfg: &Config, file: &str) -> Result<()> { + let body: CreateServiceNowTicketRequestArray = util::read_json_file(file)?; + let api = crate::make_api!(SecurityMonitoringAPI, cfg); + let resp = api + .create_service_now_tickets(body) + .await + .map_err(|e| anyhow::anyhow!("failed to create_service_now_tickets: {:?}", e))?; + let count = resp.data.len(); + let meta = formatter::Metadata { + count: Some(count), + command: Some("security findings create-servicenow-tickets".to_string()), + ..Default::default() + }; + formatter::output_with_meta(cfg, &resp, &meta) +} + +/// Detach security findings from their case +/// +/// Detach security findings from their case. +/// This operation dissociates security findings from their associated cases without deleting the cases themselves. You can detach security findings from multiple different cases in a single request, with a limit of 50 security findings per request. Security findings that are not currently attached to any case will be ignored. +pub async fn detach_case(cfg: &Config, file: &str) -> Result<()> { + let body: DetachCaseRequest = util::read_json_file(file)?; + let api = crate::make_api!(SecurityMonitoringAPI, cfg); + api.detach_case(body) + .await + .map_err(|e| anyhow::anyhow!("failed to detach_case: {:?}", e))?; + formatter::output_no_content(cfg, "security findings detach-case", None) +} + +/// Mute or unmute security findings +/// +/// Mute or unmute security findings. +/// You can mute or unmute up to 100 security findings per request. The request body must include `is_muted` and `reason` attributes. The allowed reasons depend on whether the finding is being muted or unmuted: +/// - To mute a finding: `PENDING_FIX`, `FALSE_POSITIVE`, `OTHER`, `NO_FIX`, `DUPLICATE`, `RISK_ACCEPTED`. +/// - To unmute a finding: `NO_PENDING_FIX`, `HUMAN_ERROR`, `NO_LONGER_ACCEPTED_RISK`, `OTHER`. +pub async fn mute(cfg: &Config, file: &str) -> Result<()> { + let body: MuteFindingsRequest = util::read_json_file(file)?; + let api = crate::make_api!(SecurityMonitoringAPI, cfg); + let resp = api + .mute_security_findings(body) + .await + .map_err(|e| anyhow::anyhow!("failed to mute_security_findings: {:?}", e))?; + formatter::output(cfg, &resp) +} + +/// Assign or unassign security findings +/// +/// Assign or unassign security findings. +/// You can assign up to 100 security findings per request. Set `assignee_id` to the unique identifier of the Datadog user you want to assign the findings to. Omit `assignee_id` (or set it to `null`) to unassign the findings. Per-finding warnings and failures are returned in the response `meta` object. +pub async fn assign(cfg: &Config, file: &str) -> Result<()> { + let body: AssigneeRequest = util::read_json_file(file)?; + let api = crate::make_api!(SecurityMonitoringAPI, cfg); + let resp = api + .update_findings_assignee(body) + .await + .map_err(|e| anyhow::anyhow!("failed to update_findings_assignee: {:?}", e))?; + formatter::output(cfg, &resp) +} + +/// Override the severity of security findings +/// +/// Set or clear the manual severity override of security findings. +/// +/// You can update up to 100 security findings per request. +/// Use the `set` action with a `value` to apply a manual severity override. +/// `value` is required for `set` and must be omitted for `clear`. +/// The `info` value sets the lowest severity the finding type allows. +/// Use the `clear` action to remove a manual severity override. +/// `clear` does not remove a severity set by an automation rule. +/// The optional `description` is accepted with both actions and has a limit of 280 characters. +/// +/// Auto-closed findings are excluded. +/// Findings whose severity was set by an automation rule are skipped and listed in the response `meta.warnings`. +/// If every finding is skipped this way, the request fails with a `400` error. +/// Findings that cannot be found are skipped without a warning. +/// The request fails with a `404` error only if none of the findings can be found. +pub async fn override_severity(cfg: &Config, file: &str) -> Result<()> { + let body: SeverityOverrideRequest = util::read_json_file(file)?; + let api = crate::make_api!(SecurityMonitoringAPI, cfg); + let resp = api + .update_findings_severity(body) + .await + .map_err(|e| anyhow::anyhow!("failed to update_findings_severity: {:?}", e))?; + formatter::output(cfg, &resp) +} diff --git a/src/generated/security/mod.rs b/src/generated/security/mod.rs new file mode 100644 index 00000000..b7a03d31 --- /dev/null +++ b/src/generated/security/mod.rs @@ -0,0 +1,14 @@ +// Code generated by openapi-transformer. DO NOT EDIT. + +pub mod findings; + +use anyhow::Result; + +use crate::config::Config; + +#[derive(clap::Subcommand)] +pub enum Command {} + +pub async fn run(_cfg: &Config, command: Command) -> Result<()> { + match command {} +} diff --git a/src/generated/surface.txt b/src/generated/surface.txt index 7a296027..3f88f5a4 100644 --- a/src/generated/surface.txt +++ b/src/generated/surface.txt @@ -11,3 +11,17 @@ downtime.cancel downtime.create downtime.get downtime.list +security +security.findings.assign +security.findings.attach-case +security.findings.attach-jira-issue +security.findings.attach-linear-issue +security.findings.attach-servicenow-ticket +security.findings.create-cases +security.findings.create-jira-issues +security.findings.create-linear-issues +security.findings.create-servicenow-tickets +security.findings.detach-case +security.findings.mute +security.findings.override-severity +security/findings diff --git a/src/generated/writes.rs b/src/generated/writes.rs index 73d3f182..050dc230 100644 --- a/src/generated/writes.rs +++ b/src/generated/writes.rs @@ -7,4 +7,16 @@ pub const WRITE_COMMANDS: &[&str] = &[ "authn-mappings update", "downtime cancel", "downtime create", + "security findings assign", + "security findings attach-case", + "security findings attach-jira-issue", + "security findings attach-linear-issue", + "security findings attach-servicenow-ticket", + "security findings create-cases", + "security findings create-jira-issues", + "security findings create-linear-issues", + "security findings create-servicenow-tickets", + "security findings detach-case", + "security findings mute", + "security findings override-severity", ];