From 209ee7bd8e6f11a1e53a80af6b9eb7bddda12076 Mon Sep 17 00:00:00 2001 From: "ci.datadog-api-spec" Date: Wed, 15 Jan 2025 18:54:03 +0000 Subject: [PATCH] Regenerate client from commit a3b4c237 of spec repo --- .apigentools-info | 8 +- .generator/schemas/v2/openapi.yaml | 165 + ...curity-monitoring_CreateCustomFramework.rs | 28 + ...curity-monitoring_UpdateCustomFramework.rs | 30 + src/datadog/configuration.rs | 24 +- src/datadogV2/api/api_security_monitoring.rs | 307 + src/datadogV2/model/mod.rs | 8 + .../model_create_custom_framework_request.rs | 165 + .../model/model_framework_control.rs | 102 + .../model/model_framework_requirement.rs | 105 + .../model_update_custom_framework_request.rs | 165 + .../features/v2/security_monitoring.feature | 36 + tests/scenarios/features/v2/undo.json | 12 + tests/scenarios/function_mappings.rs | 7135 +++++++++-------- 14 files changed, 4738 insertions(+), 3552 deletions(-) create mode 100644 examples/v2_security-monitoring_CreateCustomFramework.rs create mode 100644 examples/v2_security-monitoring_UpdateCustomFramework.rs create mode 100644 src/datadogV2/model/model_create_custom_framework_request.rs create mode 100644 src/datadogV2/model/model_framework_control.rs create mode 100644 src/datadogV2/model/model_framework_requirement.rs create mode 100644 src/datadogV2/model/model_update_custom_framework_request.rs diff --git a/.apigentools-info b/.apigentools-info index a00422bb6..1fc0aa881 100644 --- a/.apigentools-info +++ b/.apigentools-info @@ -4,13 +4,13 @@ "spec_versions": { "v1": { "apigentools_version": "1.6.6", - "regenerated": "2025-01-15 09:47:00.356255", - "spec_repo_commit": "21b02fc5" + "regenerated": "2025-01-15 18:48:09.130456", + "spec_repo_commit": "a3b4c237" }, "v2": { "apigentools_version": "1.6.6", - "regenerated": "2025-01-15 09:47:00.371502", - "spec_repo_commit": "21b02fc5" + "regenerated": "2025-01-15 18:48:09.147884", + "spec_repo_commit": "a3b4c237" } } } \ No newline at end of file diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index 77866cbe3..70d08d2f5 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -297,6 +297,20 @@ components: required: false schema: $ref: '#/components/schemas/RelationType' + FrameworkHandle: + description: The framework handle + in: path + name: handle + required: true + schema: + type: string + FrameworkVersion: + description: The framework version + in: path + name: version + required: true + schema: + type: string GCPSTSServiceAccountID: description: Your GCP STS enabled service account's unique ID. in: path @@ -7145,6 +7159,10 @@ components: type: string x-enum-varnames: - APPDEFINITIONS + CreateCustomFrameworkRequest: + $ref: '#/components/schemas/FrameworkData' + description: Create a custom framework. + type: object CreateDataDeletionRequestBody: description: Object needed to create a data deletion request. properties: @@ -11936,6 +11954,72 @@ components: order: $ref: '#/components/schemas/QuerySortOrder' type: object + FrameworkControl: + description: Framework Control. + properties: + name: + description: Control Name. + example: '' + type: string + rule_ids: + description: Rule IDs. + example: + - '' + items: + type: string + type: array + required: + - name + - rule_ids + type: object + FrameworkData: + description: Framework Data. + properties: + description: + description: Framework Description + type: string + handle: + description: Framework Handle + example: '' + type: string + icon_url: + description: Framework Icon URL + type: string + name: + description: Framework Name + example: '' + type: string + requirements: + description: Framework Requirements + items: + $ref: '#/components/schemas/FrameworkRequirement' + type: array + version: + description: Framework Version + example: '' + type: string + required: + - handle + - version + - name + - requirements + type: object + FrameworkRequirement: + description: Framework Requirement. + properties: + controls: + description: Requirement Controls. + items: + $ref: '#/components/schemas/FrameworkControl' + type: array + name: + description: Requirement Name. + example: '' + type: string + required: + - name + - controls + type: object FullAPIKey: description: Datadog API key. properties: @@ -28953,6 +29037,10 @@ components: deployment: $ref: '#/components/schemas/DeploymentRelationship' type: object + UpdateCustomFrameworkRequest: + $ref: '#/components/schemas/FrameworkData' + description: Update a custom framework. + type: object UpdateOpenAPIResponse: description: Response for `UpdateOpenAPI`. properties: @@ -33028,6 +33116,83 @@ paths: operator: OR permissions: - ci_visibility_read + /api/v2/cloud_security_management/custom_frameworks: + post: + description: Create a custom framework. + operationId: CreateCustomFramework + requestBody: + content: + application/json: + schema: + $ref: '#/components/schemas/CreateCustomFrameworkRequest' + required: true + responses: + '200': + description: OK + '400': + $ref: '#/components/responses/BadRequestResponse' + '429': + $ref: '#/components/responses/TooManyRequestsResponse' + '500': + $ref: '#/components/responses/BadRequestResponse' + security: + - apiKeyAuth: [] + appKeyAuth: [] + - AuthZ: + - security_monitoring_rules_read + - security_monitoring_rules_write + summary: Create a custom framework + tags: + - Security Monitoring + x-codegen-request-body-name: body + x-permission: + operator: AND + permissions: + - security_monitoring_rules_read + - security_monitoring_rules_write + x-unstable: '**Note**: This endpoint is in beta and may be subject to changes. + + Please check the documentation regularly for updates.' + /api/v2/cloud_security_management/custom_frameworks/{handle}/{version}: + put: + description: Update a custom framework. + operationId: UpdateCustomFramework + parameters: + - $ref: '#/components/parameters/FrameworkHandle' + - $ref: '#/components/parameters/FrameworkVersion' + requestBody: + content: + application/json: + schema: + $ref: '#/components/schemas/UpdateCustomFrameworkRequest' + required: true + responses: + '200': + description: OK + '400': + $ref: '#/components/responses/BadRequestResponse' + '429': + $ref: '#/components/responses/TooManyRequestsResponse' + '500': + $ref: '#/components/responses/BadRequestResponse' + security: + - apiKeyAuth: [] + appKeyAuth: [] + - AuthZ: + - security_monitoring_rules_read + - security_monitoring_rules_write + summary: Update a custom framework + tags: + - Security Monitoring + x-codegen-request-body-name: body + x-permission: + operator: AND + permissions: + - security_monitoring_rules_read + - security_monitoring_rules_write + x-unstable: '**Note**: This endpoint is in beta and may be subject to changes. + + Please check the documentation regularly for updates.' /api/v2/container_images: get: description: Get all Container Images for your organization. diff --git a/examples/v2_security-monitoring_CreateCustomFramework.rs b/examples/v2_security-monitoring_CreateCustomFramework.rs new file mode 100644 index 000000000..9f5c0d038 --- /dev/null +++ b/examples/v2_security-monitoring_CreateCustomFramework.rs @@ -0,0 +1,28 @@ +// Create a custom framework returns "OK" response +use datadog_api_client::datadog; +use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI; +use datadog_api_client::datadogV2::model::CreateCustomFrameworkRequest; +use datadog_api_client::datadogV2::model::FrameworkControl; +use datadog_api_client::datadogV2::model::FrameworkRequirement; + +#[tokio::main] +async fn main() { + let body = CreateCustomFrameworkRequest::new( + "".to_string(), + "".to_string(), + vec![FrameworkRequirement::new( + vec![FrameworkControl::new("".to_string(), vec!["".to_string()])], + "".to_string(), + )], + "".to_string(), + ); + let mut configuration = datadog::Configuration::new(); + configuration.set_unstable_operation_enabled("v2.CreateCustomFramework", true); + let api = SecurityMonitoringAPI::with_config(configuration); + let resp = api.create_custom_framework(body).await; + if let Ok(value) = resp { + println!("{:#?}", value); + } else { + println!("{:#?}", resp.unwrap_err()); + } +} diff --git a/examples/v2_security-monitoring_UpdateCustomFramework.rs b/examples/v2_security-monitoring_UpdateCustomFramework.rs new file mode 100644 index 000000000..684acec1a --- /dev/null +++ b/examples/v2_security-monitoring_UpdateCustomFramework.rs @@ -0,0 +1,30 @@ +// Update a custom framework returns "OK" response +use datadog_api_client::datadog; +use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI; +use datadog_api_client::datadogV2::model::FrameworkControl; +use datadog_api_client::datadogV2::model::FrameworkRequirement; +use datadog_api_client::datadogV2::model::UpdateCustomFrameworkRequest; + +#[tokio::main] +async fn main() { + let body = UpdateCustomFrameworkRequest::new( + "".to_string(), + "".to_string(), + vec![FrameworkRequirement::new( + vec![FrameworkControl::new("".to_string(), vec!["".to_string()])], + "".to_string(), + )], + "".to_string(), + ); + let mut configuration = datadog::Configuration::new(); + configuration.set_unstable_operation_enabled("v2.UpdateCustomFramework", true); + let api = SecurityMonitoringAPI::with_config(configuration); + let resp = api + .update_custom_framework("handle".to_string(), "version".to_string(), body) + .await; + if let Ok(value) = resp { + println!("{:#?}", value); + } else { + println!("{:#?}", resp.unwrap_err()); + } +} diff --git a/src/datadog/configuration.rs b/src/datadog/configuration.rs index daf856e73..373c7bf55 100644 --- a/src/datadog/configuration.rs +++ b/src/datadog/configuration.rs @@ -142,6 +142,19 @@ impl Default for Configuration { ("v2.get_app".to_owned(), false), ("v2.list_apps".to_owned(), false), ("v2.update_app".to_owned(), false), + ("v2.cancel_historical_job".to_owned(), false), + ("v2.convert_job_result_to_signal".to_owned(), false), + ("v2.create_custom_framework".to_owned(), false), + ("v2.delete_historical_job".to_owned(), false), + ("v2.get_finding".to_owned(), false), + ("v2.get_historical_job".to_owned(), false), + ("v2.list_findings".to_owned(), false), + ("v2.list_historical_jobs".to_owned(), false), + ("v2.list_vulnerabilities".to_owned(), false), + ("v2.list_vulnerable_assets".to_owned(), false), + ("v2.mute_findings".to_owned(), false), + ("v2.run_historical_job".to_owned(), false), + ("v2.update_custom_framework".to_owned(), false), ("v2.get_active_billing_dimensions".to_owned(), false), ("v2.get_billing_dimension_mapping".to_owned(), false), ("v2.get_monthly_cost_attribution".to_owned(), false), @@ -181,17 +194,6 @@ impl Default for Configuration { ("v2.list_aws_namespaces".to_owned(), false), ("v2.update_aws_account".to_owned(), false), ("v2.list_aws_logs_services".to_owned(), false), - ("v2.cancel_historical_job".to_owned(), false), - ("v2.convert_job_result_to_signal".to_owned(), false), - ("v2.delete_historical_job".to_owned(), false), - ("v2.get_finding".to_owned(), false), - ("v2.get_historical_job".to_owned(), false), - ("v2.list_findings".to_owned(), false), - ("v2.list_historical_jobs".to_owned(), false), - ("v2.list_vulnerabilities".to_owned(), false), - ("v2.list_vulnerable_assets".to_owned(), false), - ("v2.mute_findings".to_owned(), false), - ("v2.run_historical_job".to_owned(), false), ("v2.create_scorecard_outcomes_batch".to_owned(), false), ("v2.create_scorecard_rule".to_owned(), false), ("v2.delete_scorecard_rule".to_owned(), false), diff --git a/src/datadogV2/api/api_security_monitoring.rs b/src/datadogV2/api/api_security_monitoring.rs index 7868fa486..098409e6b 100644 --- a/src/datadogV2/api/api_security_monitoring.rs +++ b/src/datadogV2/api/api_security_monitoring.rs @@ -714,6 +714,14 @@ pub enum ConvertSecurityMonitoringRuleFromJSONToTerraformError { UnknownValue(serde_json::Value), } +/// CreateCustomFrameworkError is a struct for typed errors of method [`SecurityMonitoringAPI::create_custom_framework`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum CreateCustomFrameworkError { + APIErrorResponse(crate::datadogV2::model::APIErrorResponse), + UnknownValue(serde_json::Value), +} + /// CreateSecurityFilterError is a struct for typed errors of method [`SecurityMonitoringAPI::create_security_filter`] #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(untagged)] @@ -948,6 +956,14 @@ pub enum TestSecurityMonitoringRuleError { UnknownValue(serde_json::Value), } +/// UpdateCustomFrameworkError is a struct for typed errors of method [`SecurityMonitoringAPI::update_custom_framework`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum UpdateCustomFrameworkError { + APIErrorResponse(crate::datadogV2::model::APIErrorResponse), + UnknownValue(serde_json::Value), +} + /// UpdateSecurityFilterError is a struct for typed errors of method [`SecurityMonitoringAPI::update_security_filter`] #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(untagged)] @@ -1557,6 +1573,147 @@ impl SecurityMonitoringAPI { } } + /// Create a custom framework. + pub async fn create_custom_framework( + &self, + body: crate::datadogV2::model::CreateCustomFrameworkRequest, + ) -> Result<(), datadog::Error> { + match self.create_custom_framework_with_http_info(body).await { + Ok(_) => Ok(()), + Err(err) => Err(err), + } + } + + /// Create a custom framework. + pub async fn create_custom_framework_with_http_info( + &self, + body: crate::datadogV2::model::CreateCustomFrameworkRequest, + ) -> Result, datadog::Error> { + let local_configuration = &self.config; + let operation_id = "v2.create_custom_framework"; + if local_configuration.is_unstable_operation_enabled(operation_id) { + warn!("Using unstable operation {operation_id}"); + } else { + let local_error = datadog::UnstableOperationDisabledError { + msg: "Operation 'v2.create_custom_framework' is not enabled".to_string(), + }; + return Err(datadog::Error::UnstableOperationDisabledError(local_error)); + } + + let local_client = &self.client; + + let local_uri_str = format!( + "{}/api/v2/cloud_security_management/custom_frameworks", + local_configuration.get_operation_host(operation_id) + ); + let mut local_req_builder = + local_client.request(reqwest::Method::POST, 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("*/*")); + + // 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() { + Ok(datadog::ResponseContent { + status: local_status, + content: local_content, + entity: None, + }) + } else { + let local_entity: Option = + 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)) + } + } + /// Create a security filter. /// /// See the [security filter guide]() @@ -6147,6 +6304,156 @@ impl SecurityMonitoringAPI { } } + /// Update a custom framework. + pub async fn update_custom_framework( + &self, + handle: String, + version: String, + body: crate::datadogV2::model::UpdateCustomFrameworkRequest, + ) -> Result<(), datadog::Error> { + match self + .update_custom_framework_with_http_info(handle, version, body) + .await + { + Ok(_) => Ok(()), + Err(err) => Err(err), + } + } + + /// Update a custom framework. + pub async fn update_custom_framework_with_http_info( + &self, + handle: String, + version: String, + body: crate::datadogV2::model::UpdateCustomFrameworkRequest, + ) -> Result, datadog::Error> { + let local_configuration = &self.config; + let operation_id = "v2.update_custom_framework"; + if local_configuration.is_unstable_operation_enabled(operation_id) { + warn!("Using unstable operation {operation_id}"); + } else { + let local_error = datadog::UnstableOperationDisabledError { + msg: "Operation 'v2.update_custom_framework' is not enabled".to_string(), + }; + return Err(datadog::Error::UnstableOperationDisabledError(local_error)); + } + + let local_client = &self.client; + + let local_uri_str = format!( + "{}/api/v2/cloud_security_management/custom_frameworks/{handle}/{version}", + local_configuration.get_operation_host(operation_id), + handle = datadog::urlencode(handle), + version = datadog::urlencode(version) + ); + 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("*/*")); + + // 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() { + Ok(datadog::ResponseContent { + status: local_status, + content: local_content, + entity: None, + }) + } else { + let local_entity: Option = + 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)) + } + } + /// Update a specific security filter. /// Returns the security filter object when the request is successful. pub async fn update_security_filter( diff --git a/src/datadogV2/model/mod.rs b/src/datadogV2/model/mod.rs index 515e9ffb0..921fb4200 100644 --- a/src/datadogV2/model/mod.rs +++ b/src/datadogV2/model/mod.rs @@ -870,6 +870,14 @@ pub mod model_ci_app_test_event_type_name; pub use self::model_ci_app_test_event_type_name::CIAppTestEventTypeName; pub mod model_ci_app_test_events_request; pub use self::model_ci_app_test_events_request::CIAppTestEventsRequest; +pub mod model_create_custom_framework_request; +pub use self::model_create_custom_framework_request::CreateCustomFrameworkRequest; +pub mod model_framework_requirement; +pub use self::model_framework_requirement::FrameworkRequirement; +pub mod model_framework_control; +pub use self::model_framework_control::FrameworkControl; +pub mod model_update_custom_framework_request; +pub use self::model_update_custom_framework_request::UpdateCustomFrameworkRequest; pub mod model_container_images_response; pub use self::model_container_images_response::ContainerImagesResponse; pub mod model_container_image; diff --git a/src/datadogV2/model/model_create_custom_framework_request.rs b/src/datadogV2/model/model_create_custom_framework_request.rs new file mode 100644 index 000000000..ef836a2f5 --- /dev/null +++ b/src/datadogV2/model/model_create_custom_framework_request.rs @@ -0,0 +1,165 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Framework Data. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct CreateCustomFrameworkRequest { + /// Framework Description + #[serde(rename = "description")] + pub description: Option, + /// Framework Handle + #[serde(rename = "handle")] + pub handle: String, + /// Framework Icon URL + #[serde(rename = "icon_url")] + pub icon_url: Option, + /// Framework Name + #[serde(rename = "name")] + pub name: String, + /// Framework Requirements + #[serde(rename = "requirements")] + pub requirements: Vec, + /// Framework Version + #[serde(rename = "version")] + pub version: String, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl CreateCustomFrameworkRequest { + pub fn new( + handle: String, + name: String, + requirements: Vec, + version: String, + ) -> CreateCustomFrameworkRequest { + CreateCustomFrameworkRequest { + description: None, + handle, + icon_url: None, + name, + requirements, + version, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn description(mut self, value: String) -> Self { + self.description = Some(value); + self + } + + pub fn icon_url(mut self, value: String) -> Self { + self.icon_url = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for CreateCustomFrameworkRequest { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct CreateCustomFrameworkRequestVisitor; + impl<'a> Visitor<'a> for CreateCustomFrameworkRequestVisitor { + type Value = CreateCustomFrameworkRequest; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut description: Option = None; + let mut handle: Option = None; + let mut icon_url: Option = None; + let mut name: Option = None; + let mut requirements: Option> = + None; + let mut version: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "description" => { + if v.is_null() { + continue; + } + description = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "handle" => { + handle = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "icon_url" => { + if v.is_null() { + continue; + } + icon_url = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "name" => { + name = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "requirements" => { + requirements = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "version" => { + version = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let handle = handle.ok_or_else(|| M::Error::missing_field("handle"))?; + let name = name.ok_or_else(|| M::Error::missing_field("name"))?; + let requirements = + requirements.ok_or_else(|| M::Error::missing_field("requirements"))?; + let version = version.ok_or_else(|| M::Error::missing_field("version"))?; + + let content = CreateCustomFrameworkRequest { + description, + handle, + icon_url, + name, + requirements, + version, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(CreateCustomFrameworkRequestVisitor) + } +} diff --git a/src/datadogV2/model/model_framework_control.rs b/src/datadogV2/model/model_framework_control.rs new file mode 100644 index 000000000..d37cd98d7 --- /dev/null +++ b/src/datadogV2/model/model_framework_control.rs @@ -0,0 +1,102 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Framework Control. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct FrameworkControl { + /// Control Name. + #[serde(rename = "name")] + pub name: String, + /// Rule IDs. + #[serde(rename = "rule_ids")] + pub rule_ids: Vec, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl FrameworkControl { + pub fn new(name: String, rule_ids: Vec) -> FrameworkControl { + FrameworkControl { + name, + rule_ids, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for FrameworkControl { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct FrameworkControlVisitor; + impl<'a> Visitor<'a> for FrameworkControlVisitor { + type Value = FrameworkControl; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut name: Option = None; + let mut rule_ids: Option> = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "name" => { + name = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "rule_ids" => { + rule_ids = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let name = name.ok_or_else(|| M::Error::missing_field("name"))?; + let rule_ids = rule_ids.ok_or_else(|| M::Error::missing_field("rule_ids"))?; + + let content = FrameworkControl { + name, + rule_ids, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(FrameworkControlVisitor) + } +} diff --git a/src/datadogV2/model/model_framework_requirement.rs b/src/datadogV2/model/model_framework_requirement.rs new file mode 100644 index 000000000..2fb17eec5 --- /dev/null +++ b/src/datadogV2/model/model_framework_requirement.rs @@ -0,0 +1,105 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Framework Requirement. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct FrameworkRequirement { + /// Requirement Controls. + #[serde(rename = "controls")] + pub controls: Vec, + /// Requirement Name. + #[serde(rename = "name")] + pub name: String, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl FrameworkRequirement { + pub fn new( + controls: Vec, + name: String, + ) -> FrameworkRequirement { + FrameworkRequirement { + controls, + name, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for FrameworkRequirement { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct FrameworkRequirementVisitor; + impl<'a> Visitor<'a> for FrameworkRequirementVisitor { + type Value = FrameworkRequirement; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut controls: Option> = None; + let mut name: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "controls" => { + controls = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "name" => { + name = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let controls = controls.ok_or_else(|| M::Error::missing_field("controls"))?; + let name = name.ok_or_else(|| M::Error::missing_field("name"))?; + + let content = FrameworkRequirement { + controls, + name, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(FrameworkRequirementVisitor) + } +} diff --git a/src/datadogV2/model/model_update_custom_framework_request.rs b/src/datadogV2/model/model_update_custom_framework_request.rs new file mode 100644 index 000000000..e646c434a --- /dev/null +++ b/src/datadogV2/model/model_update_custom_framework_request.rs @@ -0,0 +1,165 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Framework Data. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct UpdateCustomFrameworkRequest { + /// Framework Description + #[serde(rename = "description")] + pub description: Option, + /// Framework Handle + #[serde(rename = "handle")] + pub handle: String, + /// Framework Icon URL + #[serde(rename = "icon_url")] + pub icon_url: Option, + /// Framework Name + #[serde(rename = "name")] + pub name: String, + /// Framework Requirements + #[serde(rename = "requirements")] + pub requirements: Vec, + /// Framework Version + #[serde(rename = "version")] + pub version: String, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl UpdateCustomFrameworkRequest { + pub fn new( + handle: String, + name: String, + requirements: Vec, + version: String, + ) -> UpdateCustomFrameworkRequest { + UpdateCustomFrameworkRequest { + description: None, + handle, + icon_url: None, + name, + requirements, + version, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn description(mut self, value: String) -> Self { + self.description = Some(value); + self + } + + pub fn icon_url(mut self, value: String) -> Self { + self.icon_url = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for UpdateCustomFrameworkRequest { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct UpdateCustomFrameworkRequestVisitor; + impl<'a> Visitor<'a> for UpdateCustomFrameworkRequestVisitor { + type Value = UpdateCustomFrameworkRequest; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut description: Option = None; + let mut handle: Option = None; + let mut icon_url: Option = None; + let mut name: Option = None; + let mut requirements: Option> = + None; + let mut version: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "description" => { + if v.is_null() { + continue; + } + description = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "handle" => { + handle = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "icon_url" => { + if v.is_null() { + continue; + } + icon_url = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "name" => { + name = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "requirements" => { + requirements = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "version" => { + version = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let handle = handle.ok_or_else(|| M::Error::missing_field("handle"))?; + let name = name.ok_or_else(|| M::Error::missing_field("name"))?; + let requirements = + requirements.ok_or_else(|| M::Error::missing_field("requirements"))?; + let version = version.ok_or_else(|| M::Error::missing_field("version"))?; + + let content = UpdateCustomFrameworkRequest { + description, + handle, + icon_url, + name, + requirements, + version, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(UpdateCustomFrameworkRequestVisitor) + } +} diff --git a/tests/scenarios/features/v2/security_monitoring.feature b/tests/scenarios/features/v2/security_monitoring.feature index 362378f63..c00fa9d0a 100644 --- a/tests/scenarios/features/v2/security_monitoring.feature +++ b/tests/scenarios/features/v2/security_monitoring.feature @@ -171,6 +171,22 @@ Feature: Security Monitoring And the response "message" is equal to "ddd" And the response "options.complianceRuleOptions.resourceType" is equal to "gcp_compute_disk" + @generated @skip @team:DataDog/k9-cloud-security-platform + Scenario: Create a custom framework returns "Bad Request" response + Given operation "CreateCustomFramework" enabled + And new "CreateCustomFramework" request + And body with value {"handle": "", "name": "", "requirements": [{"controls": [{"name": "", "rule_ids": [""]}], "name": ""}], "version": ""} + When the request is sent + Then the response status is 400 Bad Request + + @generated @skip @team:DataDog/k9-cloud-security-platform + Scenario: Create a custom framework returns "OK" response + Given operation "CreateCustomFramework" enabled + And new "CreateCustomFramework" request + And body with value {"handle": "", "name": "", "requirements": [{"controls": [{"name": "", "rule_ids": [""]}], "name": ""}], "version": ""} + When the request is sent + Then the response status is 200 OK + @team:DataDog/k9-cloud-security-platform Scenario: Create a detection rule returns "Bad Request" response Given new "CreateSecurityMonitoringRule" request @@ -827,6 +843,26 @@ Feature: Security Monitoring And the response "name" is equal to "{{ unique }}_cloud_updated" And the response "id" has the same value as "cloud_configuration_rule.id" + @generated @skip @team:DataDog/k9-cloud-security-platform + Scenario: Update a custom framework returns "Bad Request" response + Given operation "UpdateCustomFramework" enabled + And new "UpdateCustomFramework" request + And request contains "handle" parameter from "REPLACE.ME" + And request contains "version" parameter from "REPLACE.ME" + And body with value {"handle": "", "name": "", "requirements": [{"controls": [{"name": "", "rule_ids": [""]}], "name": ""}], "version": ""} + When the request is sent + Then the response status is 400 Bad Request + + @generated @skip @team:DataDog/k9-cloud-security-platform + Scenario: Update a custom framework returns "OK" response + Given operation "UpdateCustomFramework" enabled + And new "UpdateCustomFramework" request + And request contains "handle" parameter from "REPLACE.ME" + And request contains "version" parameter from "REPLACE.ME" + And body with value {"handle": "", "name": "", "requirements": [{"controls": [{"name": "", "rule_ids": [""]}], "name": ""}], "version": ""} + When the request is sent + Then the response status is 200 OK + @generated @skip @team:DataDog/k9-cloud-security-platform Scenario: Update a security filter returns "Bad Request" response Given new "UpdateSecurityFilter" request diff --git a/tests/scenarios/features/v2/undo.json b/tests/scenarios/features/v2/undo.json index d6c6e9de8..154e3c46f 100644 --- a/tests/scenarios/features/v2/undo.json +++ b/tests/scenarios/features/v2/undo.json @@ -439,6 +439,18 @@ "type": "safe" } }, + "CreateCustomFramework": { + "tag": "Security Monitoring", + "undo": { + "type": "idempotent" + } + }, + "UpdateCustomFramework": { + "tag": "Security Monitoring", + "undo": { + "type": "idempotent" + } + }, "ListContainerImages": { "tag": "Container Images", "undo": { diff --git a/tests/scenarios/function_mappings.rs b/tests/scenarios/function_mappings.rs index 2439673c5..4cd06cabb 100644 --- a/tests/scenarios/function_mappings.rs +++ b/tests/scenarios/function_mappings.rs @@ -64,6 +64,8 @@ pub struct ApiInstances { Option, pub v2_api_ci_visibility_tests: Option, + pub v2_api_security_monitoring: + Option, pub v2_api_container_images: Option, pub v2_api_containers: Option, pub v2_api_cloud_cost_management: @@ -104,8 +106,6 @@ pub struct ApiInstances { Option, pub v2_api_organizations: Option, pub v2_api_roles: Option, - pub v2_api_security_monitoring: - Option, pub v2_api_powerpack: Option, pub v2_api_processes: Option, pub v2_api_csm_threats: Option, @@ -1906,6 +1906,167 @@ pub fn collect_function_calls(world: &mut DatadogWorld) { "v2.SearchCIAppTestEventsWithPagination".into(), test_v2_search_ci_app_test_events_with_pagination, ); + world.function_mappings.insert( + "v2.CreateCustomFramework".into(), + test_v2_create_custom_framework, + ); + world.function_mappings.insert( + "v2.UpdateCustomFramework".into(), + test_v2_update_custom_framework, + ); + world + .function_mappings + .insert("v2.ListFindings".into(), test_v2_list_findings); + world.function_mappings.insert( + "v2.ListFindingsWithPagination".into(), + test_v2_list_findings_with_pagination, + ); + world + .function_mappings + .insert("v2.MuteFindings".into(), test_v2_mute_findings); + world + .function_mappings + .insert("v2.GetFinding".into(), test_v2_get_finding); + world.function_mappings.insert( + "v2.ListVulnerableAssets".into(), + test_v2_list_vulnerable_assets, + ); + world.function_mappings.insert( + "v2.ListVulnerabilities".into(), + test_v2_list_vulnerabilities, + ); + world.function_mappings.insert( + "v2.ListSecurityFilters".into(), + test_v2_list_security_filters, + ); + world.function_mappings.insert( + "v2.CreateSecurityFilter".into(), + test_v2_create_security_filter, + ); + world.function_mappings.insert( + "v2.DeleteSecurityFilter".into(), + test_v2_delete_security_filter, + ); + world + .function_mappings + .insert("v2.GetSecurityFilter".into(), test_v2_get_security_filter); + world.function_mappings.insert( + "v2.UpdateSecurityFilter".into(), + test_v2_update_security_filter, + ); + world.function_mappings.insert( + "v2.ListSecurityMonitoringSuppressions".into(), + test_v2_list_security_monitoring_suppressions, + ); + world.function_mappings.insert( + "v2.CreateSecurityMonitoringSuppression".into(), + test_v2_create_security_monitoring_suppression, + ); + world.function_mappings.insert( + "v2.DeleteSecurityMonitoringSuppression".into(), + test_v2_delete_security_monitoring_suppression, + ); + world.function_mappings.insert( + "v2.GetSecurityMonitoringSuppression".into(), + test_v2_get_security_monitoring_suppression, + ); + world.function_mappings.insert( + "v2.UpdateSecurityMonitoringSuppression".into(), + test_v2_update_security_monitoring_suppression, + ); + world.function_mappings.insert( + "v2.ListSecurityMonitoringRules".into(), + test_v2_list_security_monitoring_rules, + ); + world.function_mappings.insert( + "v2.CreateSecurityMonitoringRule".into(), + test_v2_create_security_monitoring_rule, + ); + world.function_mappings.insert( + "v2.ConvertSecurityMonitoringRuleFromJSONToTerraform".into(), + test_v2_convert_security_monitoring_rule_from_json_to_terraform, + ); + world.function_mappings.insert( + "v2.TestSecurityMonitoringRule".into(), + test_v2_test_security_monitoring_rule, + ); + world.function_mappings.insert( + "v2.ValidateSecurityMonitoringRule".into(), + test_v2_validate_security_monitoring_rule, + ); + world.function_mappings.insert( + "v2.DeleteSecurityMonitoringRule".into(), + test_v2_delete_security_monitoring_rule, + ); + world.function_mappings.insert( + "v2.GetSecurityMonitoringRule".into(), + test_v2_get_security_monitoring_rule, + ); + world.function_mappings.insert( + "v2.UpdateSecurityMonitoringRule".into(), + test_v2_update_security_monitoring_rule, + ); + world.function_mappings.insert( + "v2.ConvertExistingSecurityMonitoringRule".into(), + test_v2_convert_existing_security_monitoring_rule, + ); + world.function_mappings.insert( + "v2.TestExistingSecurityMonitoringRule".into(), + test_v2_test_existing_security_monitoring_rule, + ); + world.function_mappings.insert( + "v2.ListSecurityMonitoringSignals".into(), + test_v2_list_security_monitoring_signals, + ); + world.function_mappings.insert( + "v2.ListSecurityMonitoringSignalsWithPagination".into(), + test_v2_list_security_monitoring_signals_with_pagination, + ); + world.function_mappings.insert( + "v2.SearchSecurityMonitoringSignals".into(), + test_v2_search_security_monitoring_signals, + ); + world.function_mappings.insert( + "v2.SearchSecurityMonitoringSignalsWithPagination".into(), + test_v2_search_security_monitoring_signals_with_pagination, + ); + world.function_mappings.insert( + "v2.GetSecurityMonitoringSignal".into(), + test_v2_get_security_monitoring_signal, + ); + world.function_mappings.insert( + "v2.EditSecurityMonitoringSignalAssignee".into(), + test_v2_edit_security_monitoring_signal_assignee, + ); + world.function_mappings.insert( + "v2.EditSecurityMonitoringSignalIncidents".into(), + test_v2_edit_security_monitoring_signal_incidents, + ); + world.function_mappings.insert( + "v2.EditSecurityMonitoringSignalState".into(), + test_v2_edit_security_monitoring_signal_state, + ); + world + .function_mappings + .insert("v2.ListHistoricalJobs".into(), test_v2_list_historical_jobs); + world + .function_mappings + .insert("v2.RunHistoricalJob".into(), test_v2_run_historical_job); + world.function_mappings.insert( + "v2.ConvertJobResultToSignal".into(), + test_v2_convert_job_result_to_signal, + ); + world.function_mappings.insert( + "v2.DeleteHistoricalJob".into(), + test_v2_delete_historical_job, + ); + world + .function_mappings + .insert("v2.GetHistoricalJob".into(), test_v2_get_historical_job); + world.function_mappings.insert( + "v2.CancelHistoricalJob".into(), + test_v2_cancel_historical_job, + ); world.function_mappings.insert( "v2.ListContainerImages".into(), test_v2_list_container_images, @@ -2650,249 +2811,96 @@ pub fn collect_function_calls(world: &mut DatadogWorld) { .insert("v2.AddUserToRole".into(), test_v2_add_user_to_role); world .function_mappings - .insert("v2.ListFindings".into(), test_v2_list_findings); + .insert("v2.ListPowerpacks".into(), test_v2_list_powerpacks); world.function_mappings.insert( - "v2.ListFindingsWithPagination".into(), - test_v2_list_findings_with_pagination, + "v2.ListPowerpacksWithPagination".into(), + test_v2_list_powerpacks_with_pagination, ); world .function_mappings - .insert("v2.MuteFindings".into(), test_v2_mute_findings); + .insert("v2.CreatePowerpack".into(), test_v2_create_powerpack); world .function_mappings - .insert("v2.GetFinding".into(), test_v2_get_finding); + .insert("v2.DeletePowerpack".into(), test_v2_delete_powerpack); + world + .function_mappings + .insert("v2.GetPowerpack".into(), test_v2_get_powerpack); + world + .function_mappings + .insert("v2.UpdatePowerpack".into(), test_v2_update_powerpack); + world + .function_mappings + .insert("v2.ListProcesses".into(), test_v2_list_processes); world.function_mappings.insert( - "v2.ListVulnerableAssets".into(), - test_v2_list_vulnerable_assets, + "v2.ListProcessesWithPagination".into(), + test_v2_list_processes_with_pagination, ); world.function_mappings.insert( - "v2.ListVulnerabilities".into(), - test_v2_list_vulnerabilities, + "v2.ListCSMThreatsAgentRules".into(), + test_v2_list_csm_threats_agent_rules, ); world.function_mappings.insert( - "v2.ListSecurityFilters".into(), - test_v2_list_security_filters, + "v2.CreateCSMThreatsAgentRule".into(), + test_v2_create_csm_threats_agent_rule, ); world.function_mappings.insert( - "v2.CreateSecurityFilter".into(), - test_v2_create_security_filter, + "v2.DeleteCSMThreatsAgentRule".into(), + test_v2_delete_csm_threats_agent_rule, ); world.function_mappings.insert( - "v2.DeleteSecurityFilter".into(), - test_v2_delete_security_filter, + "v2.GetCSMThreatsAgentRule".into(), + test_v2_get_csm_threats_agent_rule, ); - world - .function_mappings - .insert("v2.GetSecurityFilter".into(), test_v2_get_security_filter); world.function_mappings.insert( - "v2.UpdateSecurityFilter".into(), - test_v2_update_security_filter, + "v2.UpdateCSMThreatsAgentRule".into(), + test_v2_update_csm_threats_agent_rule, ); world.function_mappings.insert( - "v2.ListSecurityMonitoringSuppressions".into(), - test_v2_list_security_monitoring_suppressions, + "v2.DownloadCSMThreatsPolicy".into(), + test_v2_download_csm_threats_policy, ); world.function_mappings.insert( - "v2.CreateSecurityMonitoringSuppression".into(), - test_v2_create_security_monitoring_suppression, + "v2.DownloadCloudWorkloadPolicyFile".into(), + test_v2_download_cloud_workload_policy_file, ); world.function_mappings.insert( - "v2.DeleteSecurityMonitoringSuppression".into(), - test_v2_delete_security_monitoring_suppression, + "v2.ListCloudWorkloadSecurityAgentRules".into(), + test_v2_list_cloud_workload_security_agent_rules, ); world.function_mappings.insert( - "v2.GetSecurityMonitoringSuppression".into(), - test_v2_get_security_monitoring_suppression, + "v2.CreateCloudWorkloadSecurityAgentRule".into(), + test_v2_create_cloud_workload_security_agent_rule, ); world.function_mappings.insert( - "v2.UpdateSecurityMonitoringSuppression".into(), - test_v2_update_security_monitoring_suppression, + "v2.DeleteCloudWorkloadSecurityAgentRule".into(), + test_v2_delete_cloud_workload_security_agent_rule, ); world.function_mappings.insert( - "v2.ListSecurityMonitoringRules".into(), - test_v2_list_security_monitoring_rules, + "v2.GetCloudWorkloadSecurityAgentRule".into(), + test_v2_get_cloud_workload_security_agent_rule, ); world.function_mappings.insert( - "v2.CreateSecurityMonitoringRule".into(), - test_v2_create_security_monitoring_rule, + "v2.UpdateCloudWorkloadSecurityAgentRule".into(), + test_v2_update_cloud_workload_security_agent_rule, ); world.function_mappings.insert( - "v2.ConvertSecurityMonitoringRuleFromJSONToTerraform".into(), - test_v2_convert_security_monitoring_rule_from_json_to_terraform, + "v2.DeleteRestrictionPolicy".into(), + test_v2_delete_restriction_policy, ); world.function_mappings.insert( - "v2.TestSecurityMonitoringRule".into(), - test_v2_test_security_monitoring_rule, + "v2.GetRestrictionPolicy".into(), + test_v2_get_restriction_policy, ); world.function_mappings.insert( - "v2.ValidateSecurityMonitoringRule".into(), - test_v2_validate_security_monitoring_rule, + "v2.UpdateRestrictionPolicy".into(), + test_v2_update_restriction_policy, ); - world.function_mappings.insert( - "v2.DeleteSecurityMonitoringRule".into(), - test_v2_delete_security_monitoring_rule, - ); - world.function_mappings.insert( - "v2.GetSecurityMonitoringRule".into(), - test_v2_get_security_monitoring_rule, - ); - world.function_mappings.insert( - "v2.UpdateSecurityMonitoringRule".into(), - test_v2_update_security_monitoring_rule, - ); - world.function_mappings.insert( - "v2.ConvertExistingSecurityMonitoringRule".into(), - test_v2_convert_existing_security_monitoring_rule, - ); - world.function_mappings.insert( - "v2.TestExistingSecurityMonitoringRule".into(), - test_v2_test_existing_security_monitoring_rule, - ); - world.function_mappings.insert( - "v2.ListSecurityMonitoringSignals".into(), - test_v2_list_security_monitoring_signals, - ); - world.function_mappings.insert( - "v2.ListSecurityMonitoringSignalsWithPagination".into(), - test_v2_list_security_monitoring_signals_with_pagination, - ); - world.function_mappings.insert( - "v2.SearchSecurityMonitoringSignals".into(), - test_v2_search_security_monitoring_signals, - ); - world.function_mappings.insert( - "v2.SearchSecurityMonitoringSignalsWithPagination".into(), - test_v2_search_security_monitoring_signals_with_pagination, - ); - world.function_mappings.insert( - "v2.GetSecurityMonitoringSignal".into(), - test_v2_get_security_monitoring_signal, - ); - world.function_mappings.insert( - "v2.EditSecurityMonitoringSignalAssignee".into(), - test_v2_edit_security_monitoring_signal_assignee, - ); - world.function_mappings.insert( - "v2.EditSecurityMonitoringSignalIncidents".into(), - test_v2_edit_security_monitoring_signal_incidents, - ); - world.function_mappings.insert( - "v2.EditSecurityMonitoringSignalState".into(), - test_v2_edit_security_monitoring_signal_state, - ); - world - .function_mappings - .insert("v2.ListHistoricalJobs".into(), test_v2_list_historical_jobs); - world - .function_mappings - .insert("v2.RunHistoricalJob".into(), test_v2_run_historical_job); - world.function_mappings.insert( - "v2.ConvertJobResultToSignal".into(), - test_v2_convert_job_result_to_signal, - ); - world.function_mappings.insert( - "v2.DeleteHistoricalJob".into(), - test_v2_delete_historical_job, - ); - world - .function_mappings - .insert("v2.GetHistoricalJob".into(), test_v2_get_historical_job); - world.function_mappings.insert( - "v2.CancelHistoricalJob".into(), - test_v2_cancel_historical_job, - ); - world - .function_mappings - .insert("v2.ListPowerpacks".into(), test_v2_list_powerpacks); - world.function_mappings.insert( - "v2.ListPowerpacksWithPagination".into(), - test_v2_list_powerpacks_with_pagination, - ); - world - .function_mappings - .insert("v2.CreatePowerpack".into(), test_v2_create_powerpack); - world - .function_mappings - .insert("v2.DeletePowerpack".into(), test_v2_delete_powerpack); - world - .function_mappings - .insert("v2.GetPowerpack".into(), test_v2_get_powerpack); - world - .function_mappings - .insert("v2.UpdatePowerpack".into(), test_v2_update_powerpack); - world - .function_mappings - .insert("v2.ListProcesses".into(), test_v2_list_processes); - world.function_mappings.insert( - "v2.ListProcessesWithPagination".into(), - test_v2_list_processes_with_pagination, - ); - world.function_mappings.insert( - "v2.ListCSMThreatsAgentRules".into(), - test_v2_list_csm_threats_agent_rules, - ); - world.function_mappings.insert( - "v2.CreateCSMThreatsAgentRule".into(), - test_v2_create_csm_threats_agent_rule, - ); - world.function_mappings.insert( - "v2.DeleteCSMThreatsAgentRule".into(), - test_v2_delete_csm_threats_agent_rule, - ); - world.function_mappings.insert( - "v2.GetCSMThreatsAgentRule".into(), - test_v2_get_csm_threats_agent_rule, - ); - world.function_mappings.insert( - "v2.UpdateCSMThreatsAgentRule".into(), - test_v2_update_csm_threats_agent_rule, - ); - world.function_mappings.insert( - "v2.DownloadCSMThreatsPolicy".into(), - test_v2_download_csm_threats_policy, - ); - world.function_mappings.insert( - "v2.DownloadCloudWorkloadPolicyFile".into(), - test_v2_download_cloud_workload_policy_file, - ); - world.function_mappings.insert( - "v2.ListCloudWorkloadSecurityAgentRules".into(), - test_v2_list_cloud_workload_security_agent_rules, - ); - world.function_mappings.insert( - "v2.CreateCloudWorkloadSecurityAgentRule".into(), - test_v2_create_cloud_workload_security_agent_rule, - ); - world.function_mappings.insert( - "v2.DeleteCloudWorkloadSecurityAgentRule".into(), - test_v2_delete_cloud_workload_security_agent_rule, - ); - world.function_mappings.insert( - "v2.GetCloudWorkloadSecurityAgentRule".into(), - test_v2_get_cloud_workload_security_agent_rule, - ); - world.function_mappings.insert( - "v2.UpdateCloudWorkloadSecurityAgentRule".into(), - test_v2_update_cloud_workload_security_agent_rule, - ); - world.function_mappings.insert( - "v2.DeleteRestrictionPolicy".into(), - test_v2_delete_restriction_policy, - ); - world.function_mappings.insert( - "v2.GetRestrictionPolicy".into(), - test_v2_get_restriction_policy, - ); - world.function_mappings.insert( - "v2.UpdateRestrictionPolicy".into(), - test_v2_update_restriction_policy, - ); - world - .function_mappings - .insert("v2.AggregateRUMEvents".into(), test_v2_aggregate_rum_events); - world - .function_mappings - .insert("v2.GetRUMApplications".into(), test_v2_get_rum_applications); + world + .function_mappings + .insert("v2.AggregateRUMEvents".into(), test_v2_aggregate_rum_events); + world + .function_mappings + .insert("v2.GetRUMApplications".into(), test_v2_get_rum_applications); world.function_mappings.insert( "v2.CreateRUMApplication".into(), test_v2_create_rum_application, @@ -13017,34 +13025,14 @@ fn test_v2_search_ci_app_test_events_with_pagination( world.response.code = 200; } -fn test_v2_list_container_images(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_create_custom_framework(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_container_images + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let filter_tags = _parameters - .get("filter[tags]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let group_by = _parameters - .get("group_by") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let sort = _parameters - .get("sort") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_size = _parameters - .get("page[size]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_cursor = _parameters - .get("page[cursor]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_container_images::ListContainerImagesOptionalParams::default(); - params.filter_tags = filter_tags; - params.group_by = group_by; - params.sort = sort; - params.page_size = page_size; - params.page_cursor = page_cursor; - let response = match block_on(api.list_container_images_with_http_info(params)) { + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.create_custom_framework_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -13061,92 +13049,95 @@ fn test_v2_list_container_images(world: &mut DatadogWorld, _parameters: &HashMap world.response.object = serde_json::to_value(response.entity).unwrap(); world.response.code = response.status.as_u16(); } -fn test_v2_list_container_images_with_pagination( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { + +fn test_v2_update_custom_framework(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_container_images + .v2_api_security_monitoring + .as_ref() + .expect("api instance not found"); + let handle = serde_json::from_value(_parameters.get("handle").unwrap().clone()).unwrap(); + let version = serde_json::from_value(_parameters.get("version").unwrap().clone()).unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.update_custom_framework_with_http_info(handle, version, body)) + { + 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_v2_list_findings(world: &mut DatadogWorld, _parameters: &HashMap) { + let api = world + .api_instances + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); + let page_limit = _parameters + .get("page[limit]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let snapshot_timestamp = _parameters + .get("snapshot_timestamp") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_cursor = _parameters + .get("page[cursor]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); let filter_tags = _parameters .get("filter[tags]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let group_by = _parameters - .get("group_by") + let filter_evaluation_changed_at = _parameters + .get("filter[evaluation_changed_at]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let sort = _parameters - .get("sort") + let filter_muted = _parameters + .get("filter[muted]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_size = _parameters - .get("page[size]") + let filter_rule_id = _parameters + .get("filter[rule_id]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_cursor = _parameters - .get("page[cursor]") + let filter_rule_name = _parameters + .get("filter[rule_name]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_container_images::ListContainerImagesOptionalParams::default(); - params.filter_tags = filter_tags; - params.group_by = group_by; - params.sort = sort; - params.page_size = page_size; - params.page_cursor = page_cursor; - let response = api.list_container_images_with_pagination(params); - let mut result = Vec::new(); - - block_on(async { - pin_mut!(response); - - while let Some(resp) = response.next().await { - match resp { - Ok(response) => { - result.push(response); - } - Err(error) => { - return match error { - Error::ResponseError(e) => { - 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(result).unwrap(); - world.response.code = 200; -} - -fn test_v2_list_containers(world: &mut DatadogWorld, _parameters: &HashMap) { - let api = world - .api_instances - .v2_api_containers - .as_ref() - .expect("api instance not found"); - let filter_tags = _parameters - .get("filter[tags]") + let filter_resource_type = _parameters + .get("filter[resource_type]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let group_by = _parameters - .get("group_by") + let filter_discovery_timestamp = _parameters + .get("filter[discovery_timestamp]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let sort = _parameters - .get("sort") + let filter_evaluation = _parameters + .get("filter[evaluation]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_size = _parameters - .get("page[size]") + let filter_status = _parameters + .get("filter[status]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_cursor = _parameters - .get("page[cursor]") + let filter_vulnerability_type = _parameters + .get("filter[vulnerability_type]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_containers::ListContainersOptionalParams::default(); - params.filter_tags = filter_tags; - params.group_by = group_by; - params.sort = sort; - params.page_size = page_size; + let mut params = datadogV2::api_security_monitoring::ListFindingsOptionalParams::default(); + params.page_limit = page_limit; + params.snapshot_timestamp = snapshot_timestamp; params.page_cursor = page_cursor; - let response = match block_on(api.list_containers_with_http_info(params)) { + params.filter_tags = filter_tags; + params.filter_evaluation_changed_at = filter_evaluation_changed_at; + params.filter_muted = filter_muted; + params.filter_rule_id = filter_rule_id; + params.filter_rule_name = filter_rule_name; + params.filter_resource_type = filter_resource_type; + params.filter_discovery_timestamp = filter_discovery_timestamp; + params.filter_evaluation = filter_evaluation; + params.filter_status = filter_status; + params.filter_vulnerability_type = filter_vulnerability_type; + let response = match block_on(api.list_findings_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -13163,37 +13154,69 @@ fn test_v2_list_containers(world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_containers + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); + let page_limit = _parameters + .get("page[limit]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let snapshot_timestamp = _parameters + .get("snapshot_timestamp") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_cursor = _parameters + .get("page[cursor]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); let filter_tags = _parameters .get("filter[tags]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let group_by = _parameters - .get("group_by") + let filter_evaluation_changed_at = _parameters + .get("filter[evaluation_changed_at]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let sort = _parameters - .get("sort") + let filter_muted = _parameters + .get("filter[muted]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_size = _parameters - .get("page[size]") + let filter_rule_id = _parameters + .get("filter[rule_id]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_cursor = _parameters - .get("page[cursor]") + let filter_rule_name = _parameters + .get("filter[rule_name]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_containers::ListContainersOptionalParams::default(); - params.filter_tags = filter_tags; - params.group_by = group_by; - params.sort = sort; - params.page_size = page_size; + let filter_resource_type = _parameters + .get("filter[resource_type]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_discovery_timestamp = _parameters + .get("filter[discovery_timestamp]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_evaluation = _parameters + .get("filter[evaluation]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_status = _parameters + .get("filter[status]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_vulnerability_type = _parameters + .get("filter[vulnerability_type]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_security_monitoring::ListFindingsOptionalParams::default(); + params.page_limit = page_limit; + params.snapshot_timestamp = snapshot_timestamp; params.page_cursor = page_cursor; - let response = api.list_containers_with_pagination(params); + params.filter_tags = filter_tags; + params.filter_evaluation_changed_at = filter_evaluation_changed_at; + params.filter_muted = filter_muted; + params.filter_rule_id = filter_rule_id; + params.filter_rule_name = filter_rule_name; + params.filter_resource_type = filter_resource_type; + params.filter_discovery_timestamp = filter_discovery_timestamp; + params.filter_evaluation = filter_evaluation; + params.filter_status = filter_status; + params.filter_vulnerability_type = filter_vulnerability_type; + let response = api.list_findings_with_pagination(params); let mut result = Vec::new(); block_on(async { @@ -13221,16 +13244,14 @@ fn test_v2_list_containers_with_pagination( world.response.code = 200; } -fn test_v2_list_cost_awscur_configs( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_mute_findings(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_cloud_cost_management + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let response = match block_on(api.list_cost_awscur_configs_with_http_info()) { + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.mute_findings_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -13248,17 +13269,20 @@ fn test_v2_list_cost_awscur_configs( world.response.code = response.status.as_u16(); } -fn test_v2_create_cost_awscur_config( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_get_finding(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_cloud_cost_management + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_cost_awscur_config_with_http_info(body)) { + let finding_id = + serde_json::from_value(_parameters.get("finding_id").unwrap().clone()).unwrap(); + let snapshot_timestamp = _parameters + .get("snapshot_timestamp") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_security_monitoring::GetFindingOptionalParams::default(); + params.snapshot_timestamp = snapshot_timestamp; + let response = match block_on(api.get_finding_with_http_info(finding_id, params)) { Ok(response) => response, Err(error) => { return match error { @@ -13276,18 +13300,79 @@ fn test_v2_create_cost_awscur_config( world.response.code = response.status.as_u16(); } -fn test_v2_delete_cost_awscur_config( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_list_vulnerable_assets(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_cloud_cost_management + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let cloud_account_id = - serde_json::from_value(_parameters.get("cloud_account_id").unwrap().clone()).unwrap(); - let response = match block_on(api.delete_cost_awscur_config_with_http_info(cloud_account_id)) { + let page_token = _parameters + .get("page[token]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_number = _parameters + .get("page[number]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_name = _parameters + .get("filter[name]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_type = _parameters + .get("filter[type]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_version_first = _parameters + .get("filter[version.first]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_version_last = _parameters + .get("filter[version.last]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_repository_url = _parameters + .get("filter[repository_url]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_risks_in_production = _parameters + .get("filter[risks.in_production]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_risks_under_attack = _parameters + .get("filter[risks.under_attack]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_risks_is_publicly_accessible = _parameters + .get("filter[risks.is_publicly_accessible]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_risks_has_privileged_access = _parameters + .get("filter[risks.has_privileged_access]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_risks_has_access_to_sensitive_data = _parameters + .get("filter[risks.has_access_to_sensitive_data]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_environments = _parameters + .get("filter[environments]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_arch = _parameters + .get("filter[arch]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_operating_system_name = _parameters + .get("filter[operating_system.name]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_operating_system_version = _parameters + .get("filter[operating_system.version]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = + datadogV2::api_security_monitoring::ListVulnerableAssetsOptionalParams::default(); + params.page_token = page_token; + params.page_number = page_number; + params.filter_name = filter_name; + params.filter_type = filter_type; + params.filter_version_first = filter_version_first; + params.filter_version_last = filter_version_last; + params.filter_repository_url = filter_repository_url; + params.filter_risks_in_production = filter_risks_in_production; + params.filter_risks_under_attack = filter_risks_under_attack; + params.filter_risks_is_publicly_accessible = filter_risks_is_publicly_accessible; + params.filter_risks_has_privileged_access = filter_risks_has_privileged_access; + params.filter_risks_has_access_to_sensitive_data = filter_risks_has_access_to_sensitive_data; + params.filter_environments = filter_environments; + params.filter_arch = filter_arch; + params.filter_operating_system_name = filter_operating_system_name; + params.filter_operating_system_version = filter_operating_system_version; + let response = match block_on(api.list_vulnerable_assets_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -13305,47 +13390,200 @@ fn test_v2_delete_cost_awscur_config( world.response.code = response.status.as_u16(); } -fn test_v2_update_cost_awscur_config( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_list_vulnerabilities(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_cloud_cost_management + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let cloud_account_id = - serde_json::from_value(_parameters.get("cloud_account_id").unwrap().clone()).unwrap(); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = - match block_on(api.update_cost_awscur_config_with_http_info(cloud_account_id, body)) { - 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 page_token = _parameters + .get("page[token]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_number = _parameters + .get("page[number]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_type = _parameters + .get("filter[type]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_cvss_base_score_op = _parameters + .get("filter[cvss.base.score][`$op`]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_cvss_base_severity = _parameters + .get("filter[cvss.base.severity]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_cvss_base_vector = _parameters + .get("filter[cvss.base.vector]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_cvss_datadog_score_op = _parameters + .get("filter[cvss.datadog.score][`$op`]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_cvss_datadog_severity = _parameters + .get("filter[cvss.datadog.severity]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_cvss_datadog_vector = _parameters + .get("filter[cvss.datadog.vector]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_status = _parameters + .get("filter[status]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_tool = _parameters + .get("filter[tool]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_library_name = _parameters + .get("filter[library.name]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_library_version = _parameters + .get("filter[library.version]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_advisory_id = _parameters + .get("filter[advisory_id]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_risks_exploitation_probability = _parameters + .get("filter[risks.exploitation_probability]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_risks_poc_exploit_available = _parameters + .get("filter[risks.poc_exploit_available]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_risks_exploit_available = _parameters + .get("filter[risks.exploit_available]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_risks_epss_score_op = _parameters + .get("filter[risks.epss.score][`$op`]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_risks_epss_severity = _parameters + .get("filter[risks.epss.severity]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_language = _parameters + .get("filter[language]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_ecosystem = _parameters + .get("filter[ecosystem]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_code_location_location = _parameters + .get("filter[code_location.location]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_code_location_file_path = _parameters + .get("filter[code_location.file_path]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_code_location_method = _parameters + .get("filter[code_location.method]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_fix_available = _parameters + .get("filter[fix_available]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_repo_digests = _parameters + .get("filter[repo_digests]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_asset_name = _parameters + .get("filter[asset.name]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_asset_type = _parameters + .get("filter[asset.type]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_asset_version_first = _parameters + .get("filter[asset.version.first]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_asset_version_last = _parameters + .get("filter[asset.version.last]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_asset_repository_url = _parameters + .get("filter[asset.repository_url]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_asset_risks_in_production = _parameters + .get("filter[asset.risks.in_production]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_asset_risks_under_attack = _parameters + .get("filter[asset.risks.under_attack]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_asset_risks_is_publicly_accessible = _parameters + .get("filter[asset.risks.is_publicly_accessible]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_asset_risks_has_privileged_access = _parameters + .get("filter[asset.risks.has_privileged_access]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_asset_risks_has_access_to_sensitive_data = _parameters + .get("filter[asset.risks.has_access_to_sensitive_data]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_asset_environments = _parameters + .get("filter[asset.environments]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_asset_arch = _parameters + .get("filter[asset.arch]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_asset_operating_system_name = _parameters + .get("filter[asset.operating_system.name]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_asset_operating_system_version = _parameters + .get("filter[asset.operating_system.version]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = + datadogV2::api_security_monitoring::ListVulnerabilitiesOptionalParams::default(); + params.page_token = page_token; + params.page_number = page_number; + params.filter_type = filter_type; + params.filter_cvss_base_score_op = filter_cvss_base_score_op; + params.filter_cvss_base_severity = filter_cvss_base_severity; + params.filter_cvss_base_vector = filter_cvss_base_vector; + params.filter_cvss_datadog_score_op = filter_cvss_datadog_score_op; + params.filter_cvss_datadog_severity = filter_cvss_datadog_severity; + params.filter_cvss_datadog_vector = filter_cvss_datadog_vector; + params.filter_status = filter_status; + params.filter_tool = filter_tool; + params.filter_library_name = filter_library_name; + params.filter_library_version = filter_library_version; + params.filter_advisory_id = filter_advisory_id; + params.filter_risks_exploitation_probability = filter_risks_exploitation_probability; + params.filter_risks_poc_exploit_available = filter_risks_poc_exploit_available; + params.filter_risks_exploit_available = filter_risks_exploit_available; + params.filter_risks_epss_score_op = filter_risks_epss_score_op; + params.filter_risks_epss_severity = filter_risks_epss_severity; + params.filter_language = filter_language; + params.filter_ecosystem = filter_ecosystem; + params.filter_code_location_location = filter_code_location_location; + params.filter_code_location_file_path = filter_code_location_file_path; + params.filter_code_location_method = filter_code_location_method; + params.filter_fix_available = filter_fix_available; + params.filter_repo_digests = filter_repo_digests; + params.filter_asset_name = filter_asset_name; + params.filter_asset_type = filter_asset_type; + params.filter_asset_version_first = filter_asset_version_first; + params.filter_asset_version_last = filter_asset_version_last; + params.filter_asset_repository_url = filter_asset_repository_url; + params.filter_asset_risks_in_production = filter_asset_risks_in_production; + params.filter_asset_risks_under_attack = filter_asset_risks_under_attack; + params.filter_asset_risks_is_publicly_accessible = filter_asset_risks_is_publicly_accessible; + params.filter_asset_risks_has_privileged_access = filter_asset_risks_has_privileged_access; + params.filter_asset_risks_has_access_to_sensitive_data = + filter_asset_risks_has_access_to_sensitive_data; + params.filter_asset_environments = filter_asset_environments; + params.filter_asset_arch = filter_asset_arch; + params.filter_asset_operating_system_name = filter_asset_operating_system_name; + params.filter_asset_operating_system_version = filter_asset_operating_system_version; + let response = match block_on(api.list_vulnerabilities_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(); } -fn test_v2_list_cost_azure_uc_configs( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_list_security_filters(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_cloud_cost_management + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let response = match block_on(api.list_cost_azure_uc_configs_with_http_info()) { + let response = match block_on(api.list_security_filters_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -13363,17 +13601,14 @@ fn test_v2_list_cost_azure_uc_configs( world.response.code = response.status.as_u16(); } -fn test_v2_create_cost_azure_uc_configs( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_create_security_filter(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_cloud_cost_management + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_cost_azure_uc_configs_with_http_info(body)) { + let response = match block_on(api.create_security_filter_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -13391,19 +13626,15 @@ fn test_v2_create_cost_azure_uc_configs( world.response.code = response.status.as_u16(); } -fn test_v2_delete_cost_azure_uc_config( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_delete_security_filter(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_cloud_cost_management + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let cloud_account_id = - serde_json::from_value(_parameters.get("cloud_account_id").unwrap().clone()).unwrap(); - let response = match block_on(api.delete_cost_azure_uc_config_with_http_info(cloud_account_id)) - { + let security_filter_id = + serde_json::from_value(_parameters.get("security_filter_id").unwrap().clone()).unwrap(); + let response = match block_on(api.delete_security_filter_with_http_info(security_filter_id)) { Ok(response) => response, Err(error) => { return match error { @@ -13421,20 +13652,43 @@ fn test_v2_delete_cost_azure_uc_config( world.response.code = response.status.as_u16(); } -fn test_v2_update_cost_azure_uc_configs( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_get_security_filter(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_cloud_cost_management + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let cloud_account_id = - serde_json::from_value(_parameters.get("cloud_account_id").unwrap().clone()).unwrap(); + let security_filter_id = + serde_json::from_value(_parameters.get("security_filter_id").unwrap().clone()).unwrap(); + let response = match block_on(api.get_security_filter_with_http_info(security_filter_id)) { + 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_v2_update_security_filter(world: &mut DatadogWorld, _parameters: &HashMap) { + let api = world + .api_instances + .v2_api_security_monitoring + .as_ref() + .expect("api instance not found"); + let security_filter_id = + serde_json::from_value(_parameters.get("security_filter_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); let response = - match block_on(api.update_cost_azure_uc_configs_with_http_info(cloud_account_id, body)) { + match block_on(api.update_security_filter_with_http_info(security_filter_id, body)) { Ok(response) => response, Err(error) => { return match error { @@ -13452,13 +13706,16 @@ fn test_v2_update_cost_azure_uc_configs( world.response.code = response.status.as_u16(); } -fn test_v2_list_custom_costs_files(world: &mut DatadogWorld, _parameters: &HashMap) { - let api = world - .api_instances - .v2_api_cloud_cost_management +fn test_v2_list_security_monitoring_suppressions( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { + let api = world + .api_instances + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let response = match block_on(api.list_custom_costs_files_with_http_info()) { + let response = match block_on(api.list_security_monitoring_suppressions_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -13476,17 +13733,17 @@ fn test_v2_list_custom_costs_files(world: &mut DatadogWorld, _parameters: &HashM world.response.code = response.status.as_u16(); } -fn test_v2_upload_custom_costs_file( +fn test_v2_create_security_monitoring_suppression( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_cloud_cost_management + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.upload_custom_costs_file_with_http_info(body)) { + let response = match block_on(api.create_security_monitoring_suppression_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -13504,17 +13761,81 @@ fn test_v2_upload_custom_costs_file( world.response.code = response.status.as_u16(); } -fn test_v2_delete_custom_costs_file( +fn test_v2_delete_security_monitoring_suppression( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_cloud_cost_management + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let file_id = serde_json::from_value(_parameters.get("file_id").unwrap().clone()).unwrap(); - let response = match block_on(api.delete_custom_costs_file_with_http_info(file_id)) { + let suppression_id = + serde_json::from_value(_parameters.get("suppression_id").unwrap().clone()).unwrap(); + let response = + match block_on(api.delete_security_monitoring_suppression_with_http_info(suppression_id)) { + 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_v2_get_security_monitoring_suppression( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { + let api = world + .api_instances + .v2_api_security_monitoring + .as_ref() + .expect("api instance not found"); + let suppression_id = + serde_json::from_value(_parameters.get("suppression_id").unwrap().clone()).unwrap(); + let response = + match block_on(api.get_security_monitoring_suppression_with_http_info(suppression_id)) { + 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_v2_update_security_monitoring_suppression( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { + let api = world + .api_instances + .v2_api_security_monitoring + .as_ref() + .expect("api instance not found"); + let suppression_id = + serde_json::from_value(_parameters.get("suppression_id").unwrap().clone()).unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on( + api.update_security_monitoring_suppression_with_http_info(suppression_id, body), + ) { Ok(response) => response, Err(error) => { return match error { @@ -13532,14 +13853,26 @@ fn test_v2_delete_custom_costs_file( world.response.code = response.status.as_u16(); } -fn test_v2_get_custom_costs_file(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_security_monitoring_rules( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_cloud_cost_management + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let file_id = serde_json::from_value(_parameters.get("file_id").unwrap().clone()).unwrap(); - let response = match block_on(api.get_custom_costs_file_with_http_info(file_id)) { + let page_size = _parameters + .get("page[size]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_number = _parameters + .get("page[number]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = + datadogV2::api_security_monitoring::ListSecurityMonitoringRulesOptionalParams::default(); + params.page_size = page_size; + params.page_number = page_number; + let response = match block_on(api.list_security_monitoring_rules_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -13557,16 +13890,17 @@ fn test_v2_get_custom_costs_file(world: &mut DatadogWorld, _parameters: &HashMap world.response.code = response.status.as_u16(); } -fn test_v2_get_active_billing_dimensions( +fn test_v2_create_security_monitoring_rule( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_usage_metering + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let response = match block_on(api.get_active_billing_dimensions_with_http_info()) { + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.create_security_monitoring_rule_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -13584,49 +13918,19 @@ fn test_v2_get_active_billing_dimensions( world.response.code = response.status.as_u16(); } -fn test_v2_get_monthly_cost_attribution( +fn test_v2_convert_security_monitoring_rule_from_json_to_terraform( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_usage_metering + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let start_month = - serde_json::from_value(_parameters.get("start_month").unwrap().clone()).unwrap(); - let fields = serde_json::from_value(_parameters.get("fields").unwrap().clone()).unwrap(); - let end_month = _parameters - .get("end_month") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let sort_direction = _parameters - .get("sort_direction") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let sort_name = _parameters - .get("sort_name") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let tag_breakdown_keys = _parameters - .get("tag_breakdown_keys") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let next_record_id = _parameters - .get("next_record_id") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let include_descendants = _parameters - .get("include_descendants") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = - datadogV2::api_usage_metering::GetMonthlyCostAttributionOptionalParams::default(); - params.end_month = end_month; - params.sort_direction = sort_direction; - params.sort_name = sort_name; - params.tag_breakdown_keys = tag_breakdown_keys; - params.next_record_id = next_record_id; - params.include_descendants = include_descendants; - let response = match block_on(api.get_monthly_cost_attribution_with_http_info( - start_month, - fields, - params, - )) { + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on( + api.convert_security_monitoring_rule_from_json_to_terraform_with_http_info(body), + ) { Ok(response) => response, Err(error) => { return match error { @@ -13644,26 +13948,17 @@ fn test_v2_get_monthly_cost_attribution( world.response.code = response.status.as_u16(); } -fn test_v2_get_usage_application_security_monitoring( +fn test_v2_test_security_monitoring_rule( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_usage_metering + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let start_hr = serde_json::from_value(_parameters.get("start_hr").unwrap().clone()).unwrap(); - let end_hr = _parameters - .get("end_hr") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = - datadogV2::api_usage_metering::GetUsageApplicationSecurityMonitoringOptionalParams::default( - ); - params.end_hr = end_hr; - let response = match block_on( - api.get_usage_application_security_monitoring_with_http_info(start_hr, params), - ) { + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.test_security_monitoring_rule_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -13681,26 +13976,17 @@ fn test_v2_get_usage_application_security_monitoring( world.response.code = response.status.as_u16(); } -fn test_v2_get_billing_dimension_mapping( +fn test_v2_validate_security_monitoring_rule( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_usage_metering + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let filter_month = _parameters - .get("filter[month]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_view = _parameters - .get("filter[view]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = - datadogV2::api_usage_metering::GetBillingDimensionMappingOptionalParams::default(); - params.filter_month = filter_month; - params.filter_view = filter_view; - let response = match block_on(api.get_billing_dimension_mapping_with_http_info(params)) { + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.validate_security_monitoring_rule_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -13718,20 +14004,17 @@ fn test_v2_get_billing_dimension_mapping( world.response.code = response.status.as_u16(); } -fn test_v2_get_cost_by_org(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_delete_security_monitoring_rule( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_usage_metering + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let start_month = - serde_json::from_value(_parameters.get("start_month").unwrap().clone()).unwrap(); - let end_month = _parameters - .get("end_month") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_usage_metering::GetCostByOrgOptionalParams::default(); - params.end_month = end_month; - let response = match block_on(api.get_cost_by_org_with_http_info(start_month, params)) { + let rule_id = serde_json::from_value(_parameters.get("rule_id").unwrap().clone()).unwrap(); + let response = match block_on(api.delete_security_monitoring_rule_with_http_info(rule_id)) { Ok(response) => response, Err(error) => { return match error { @@ -13749,41 +14032,17 @@ fn test_v2_get_cost_by_org(world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_usage_metering + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let view = _parameters - .get("view") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let start_month = _parameters - .get("start_month") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let end_month = _parameters - .get("end_month") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let start_date = _parameters - .get("start_date") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let end_date = _parameters - .get("end_date") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let include_connected_accounts = _parameters - .get("include_connected_accounts") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_usage_metering::GetEstimatedCostByOrgOptionalParams::default(); - params.view = view; - params.start_month = start_month; - params.end_month = end_month; - params.start_date = start_date; - params.end_date = end_date; - params.include_connected_accounts = include_connected_accounts; - let response = match block_on(api.get_estimated_cost_by_org_with_http_info(params)) { + let rule_id = serde_json::from_value(_parameters.get("rule_id").unwrap().clone()).unwrap(); + let response = match block_on(api.get_security_monitoring_rule_with_http_info(rule_id)) { Ok(response) => response, Err(error) => { return match error { @@ -13801,95 +14060,19 @@ fn test_v2_get_estimated_cost_by_org( world.response.code = response.status.as_u16(); } -fn test_v2_get_historical_cost_by_org( +fn test_v2_update_security_monitoring_rule( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_usage_metering + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let start_month = - serde_json::from_value(_parameters.get("start_month").unwrap().clone()).unwrap(); - let view = _parameters - .get("view") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let end_month = _parameters - .get("end_month") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let include_connected_accounts = _parameters - .get("include_connected_accounts") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_usage_metering::GetHistoricalCostByOrgOptionalParams::default(); - params.view = view; - params.end_month = end_month; - params.include_connected_accounts = include_connected_accounts; - let response = - match block_on(api.get_historical_cost_by_org_with_http_info(start_month, 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}"), - }; - } - }; - world.response.object = serde_json::to_value(response.entity).unwrap(); - world.response.code = response.status.as_u16(); -} - -fn test_v2_get_hourly_usage(world: &mut DatadogWorld, _parameters: &HashMap) { - let api = world - .api_instances - .v2_api_usage_metering - .as_ref() - .expect("api instance not found"); - let filter_timestamp_start = - serde_json::from_value(_parameters.get("filter[timestamp][start]").unwrap().clone()) - .unwrap(); - let filter_product_families = - serde_json::from_value(_parameters.get("filter[product_families]").unwrap().clone()) - .unwrap(); - let filter_timestamp_end = _parameters - .get("filter[timestamp][end]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_include_descendants = _parameters - .get("filter[include_descendants]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_include_connected_accounts = _parameters - .get("filter[include_connected_accounts]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_include_breakdown = _parameters - .get("filter[include_breakdown]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_versions = _parameters - .get("filter[versions]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_limit = _parameters - .get("page[limit]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_next_record_id = _parameters - .get("page[next_record_id]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_usage_metering::GetHourlyUsageOptionalParams::default(); - params.filter_timestamp_end = filter_timestamp_end; - params.filter_include_descendants = filter_include_descendants; - params.filter_include_connected_accounts = filter_include_connected_accounts; - params.filter_include_breakdown = filter_include_breakdown; - params.filter_versions = filter_versions; - params.page_limit = page_limit; - params.page_next_record_id = page_next_record_id; - let response = match block_on(api.get_hourly_usage_with_http_info( - filter_timestamp_start, - filter_product_families, - params, - )) { + let rule_id = serde_json::from_value(_parameters.get("rule_id").unwrap().clone()).unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.update_security_monitoring_rule_with_http_info(rule_id, body)) + { Ok(response) => response, Err(error) => { return match error { @@ -13907,24 +14090,18 @@ fn test_v2_get_hourly_usage(world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_usage_metering + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let start_hr = serde_json::from_value(_parameters.get("start_hr").unwrap().clone()).unwrap(); - let end_hr = _parameters - .get("end_hr") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = - datadogV2::api_usage_metering::GetUsageLambdaTracedInvocationsOptionalParams::default(); - params.end_hr = end_hr; + let rule_id = serde_json::from_value(_parameters.get("rule_id").unwrap().clone()).unwrap(); let response = - match block_on(api.get_usage_lambda_traced_invocations_with_http_info(start_hr, params)) { + match block_on(api.convert_existing_security_monitoring_rule_with_http_info(rule_id)) { Ok(response) => response, Err(error) => { return match error { @@ -13942,24 +14119,19 @@ fn test_v2_get_usage_lambda_traced_invocations( world.response.code = response.status.as_u16(); } -fn test_v2_get_usage_observability_pipelines( +fn test_v2_test_existing_security_monitoring_rule( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_usage_metering + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let start_hr = serde_json::from_value(_parameters.get("start_hr").unwrap().clone()).unwrap(); - let end_hr = _parameters - .get("end_hr") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = - datadogV2::api_usage_metering::GetUsageObservabilityPipelinesOptionalParams::default(); - params.end_hr = end_hr; + let rule_id = serde_json::from_value(_parameters.get("rule_id").unwrap().clone()).unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); let response = - match block_on(api.get_usage_observability_pipelines_with_http_info(start_hr, params)) { + match block_on(api.test_existing_security_monitoring_rule_with_http_info(rule_id, body)) { Ok(response) => response, Err(error) => { return match error { @@ -13977,22 +14149,42 @@ fn test_v2_get_usage_observability_pipelines( world.response.code = response.status.as_u16(); } -fn test_v2_get_projected_cost(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_security_monitoring_signals( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_usage_metering + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let view = _parameters - .get("view") + let filter_query = _parameters + .get("filter[query]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let include_connected_accounts = _parameters - .get("include_connected_accounts") + let filter_from = _parameters + .get("filter[from]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_usage_metering::GetProjectedCostOptionalParams::default(); - params.view = view; - params.include_connected_accounts = include_connected_accounts; - let response = match block_on(api.get_projected_cost_with_http_info(params)) { + let filter_to = _parameters + .get("filter[to]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let sort = _parameters + .get("sort") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_cursor = _parameters + .get("page[cursor]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_limit = _parameters + .get("page[limit]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = + datadogV2::api_security_monitoring::ListSecurityMonitoringSignalsOptionalParams::default(); + params.filter_query = filter_query; + params.filter_from = filter_from; + params.filter_to = filter_to; + params.sort = sort; + params.page_cursor = page_cursor; + params.page_limit = page_limit; + let response = match block_on(api.list_security_monitoring_signals_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -14009,75 +14201,86 @@ fn test_v2_get_projected_cost(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_security_monitoring_signals_with_pagination( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_csm_agents + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let page = _parameters - .get("page") + let filter_query = _parameters + .get("filter[query]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let size = _parameters - .get("size") + let filter_from = _parameters + .get("filter[from]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let query = _parameters - .get("query") + let filter_to = _parameters + .get("filter[to]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let order_direction = _parameters - .get("order_direction") + let sort = _parameters + .get("sort") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_csm_agents::ListAllCSMAgentsOptionalParams::default(); - params.page = page; - params.size = size; - params.query = query; - params.order_direction = order_direction; - let response = match block_on(api.list_all_csm_agents_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(); - } + let page_cursor = _parameters + .get("page[cursor]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_limit = _parameters + .get("page[limit]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = + datadogV2::api_security_monitoring::ListSecurityMonitoringSignalsOptionalParams::default(); + params.filter_query = filter_query; + params.filter_from = filter_from; + params.filter_to = filter_to; + params.sort = sort; + params.page_cursor = page_cursor; + params.page_limit = page_limit; + let response = api.list_security_monitoring_signals_with_pagination(params); + let mut result = Vec::new(); + + block_on(async { + pin_mut!(response); + + while let Some(resp) = response.next().await { + match resp { + Ok(response) => { + result.push(response); } - _ => panic!("error parsing response: {error}"), - }; + Err(error) => { + return match error { + Error::ResponseError(e) => { + 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(); + }); + world.response.object = serde_json::to_value(result).unwrap(); + world.response.code = 200; } -fn test_v2_list_all_csm_serverless_agents( +fn test_v2_search_security_monitoring_signals( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_csm_agents + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let page = _parameters - .get("page") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let size = _parameters - .get("size") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let query = _parameters - .get("query") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let order_direction = _parameters - .get("order_direction") + let body = _parameters + .get("body") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_csm_agents::ListAllCSMServerlessAgentsOptionalParams::default(); - params.page = page; - params.size = size; - params.query = query; - params.order_direction = order_direction; - let response = match block_on(api.list_all_csm_serverless_agents_with_http_info(params)) { + let mut params = + datadogV2::api_security_monitoring::SearchSecurityMonitoringSignalsOptionalParams::default( + ); + params.body = body; + let response = match block_on(api.search_security_monitoring_signals_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -14094,72 +14297,61 @@ fn test_v2_list_all_csm_serverless_agents( world.response.object = serde_json::to_value(response.entity).unwrap(); world.response.code = response.status.as_u16(); } - -fn test_v2_get_csm_cloud_accounts_coverage_analysis( +fn test_v2_search_security_monitoring_signals_with_pagination( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_csm_coverage_analysis + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let response = match block_on(api.get_csm_cloud_accounts_coverage_analysis_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(); - } - } - _ => panic!("error parsing response: {error}"), - }; - } - }; - world.response.object = serde_json::to_value(response.entity).unwrap(); - world.response.code = response.status.as_u16(); -} + let body = _parameters + .get("body") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = + datadogV2::api_security_monitoring::SearchSecurityMonitoringSignalsOptionalParams::default( + ); + params.body = body; + let response = api.search_security_monitoring_signals_with_pagination(params); + let mut result = Vec::new(); -fn test_v2_get_csm_hosts_and_containers_coverage_analysis( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { - let api = world - .api_instances - .v2_api_csm_coverage_analysis - .as_ref() - .expect("api instance not found"); - let response = - match block_on(api.get_csm_hosts_and_containers_coverage_analysis_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(); + block_on(async { + pin_mut!(response); + + while let Some(resp) = response.next().await { + match resp { + Ok(response) => { + result.push(response); + } + Err(error) => { + return match error { + Error::ResponseError(e) => { + 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(); + } + }); + world.response.object = serde_json::to_value(result).unwrap(); + world.response.code = 200; } -fn test_v2_get_csm_serverless_coverage_analysis( +fn test_v2_get_security_monitoring_signal( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_csm_coverage_analysis + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let response = match block_on(api.get_csm_serverless_coverage_analysis_with_http_info()) { + let signal_id = serde_json::from_value(_parameters.get("signal_id").unwrap().clone()).unwrap(); + let response = match block_on(api.get_security_monitoring_signal_with_http_info(signal_id)) { Ok(response) => response, Err(error) => { return match error { @@ -14177,49 +14369,20 @@ fn test_v2_get_csm_serverless_coverage_analysis( world.response.code = response.status.as_u16(); } -fn test_v2_delete_dashboard_list_items( +fn test_v2_edit_security_monitoring_signal_assignee( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_dashboard_lists + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let dashboard_list_id = - serde_json::from_value(_parameters.get("dashboard_list_id").unwrap().clone()).unwrap(); + let signal_id = serde_json::from_value(_parameters.get("signal_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = - match block_on(api.delete_dashboard_list_items_with_http_info(dashboard_list_id, body)) { - 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_v2_get_dashboard_list_items( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { - let api = world - .api_instances - .v2_api_dashboard_lists - .as_ref() - .expect("api instance not found"); - let dashboard_list_id = - serde_json::from_value(_parameters.get("dashboard_list_id").unwrap().clone()).unwrap(); - let response = match block_on(api.get_dashboard_list_items_with_http_info(dashboard_list_id)) { + let response = match block_on( + api.edit_security_monitoring_signal_assignee_with_http_info(signal_id, body), + ) { Ok(response) => response, Err(error) => { return match error { @@ -14237,51 +14400,50 @@ fn test_v2_get_dashboard_list_items( world.response.code = response.status.as_u16(); } -fn test_v2_create_dashboard_list_items( +fn test_v2_edit_security_monitoring_signal_incidents( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_dashboard_lists + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let dashboard_list_id = - serde_json::from_value(_parameters.get("dashboard_list_id").unwrap().clone()).unwrap(); + let signal_id = serde_json::from_value(_parameters.get("signal_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = - match block_on(api.create_dashboard_list_items_with_http_info(dashboard_list_id, body)) { - 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 response = match block_on( + api.edit_security_monitoring_signal_incidents_with_http_info(signal_id, body), + ) { + 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(); } -fn test_v2_update_dashboard_list_items( +fn test_v2_edit_security_monitoring_signal_state( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_dashboard_lists + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let dashboard_list_id = - serde_json::from_value(_parameters.get("dashboard_list_id").unwrap().clone()).unwrap(); + let signal_id = serde_json::from_value(_parameters.get("signal_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); let response = - match block_on(api.update_dashboard_list_items_with_http_info(dashboard_list_id, body)) { + match block_on(api.edit_security_monitoring_signal_state_with_http_info(signal_id, body)) { Ok(response) => response, Err(error) => { return match error { @@ -14299,18 +14461,31 @@ fn test_v2_update_dashboard_list_items( world.response.code = response.status.as_u16(); } -fn test_v2_create_data_deletion_request( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_list_historical_jobs(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_data_deletion + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let product = serde_json::from_value(_parameters.get("product").unwrap().clone()).unwrap(); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_data_deletion_request_with_http_info(product, body)) { + let page_size = _parameters + .get("page[size]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_number = _parameters + .get("page[number]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let sort = _parameters + .get("sort") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_query = _parameters + .get("filter[query]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = + datadogV2::api_security_monitoring::ListHistoricalJobsOptionalParams::default(); + params.page_size = page_size; + params.page_number = page_number; + params.sort = sort; + params.filter_query = filter_query; + let response = match block_on(api.list_historical_jobs_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -14328,37 +14503,14 @@ fn test_v2_create_data_deletion_request( world.response.code = response.status.as_u16(); } -fn test_v2_get_data_deletion_requests( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_run_historical_job(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_data_deletion + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let next_page = _parameters - .get("next_page") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let product = _parameters - .get("product") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let query = _parameters - .get("query") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let status = _parameters - .get("status") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_size = _parameters - .get("page_size") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_data_deletion::GetDataDeletionRequestsOptionalParams::default(); - params.next_page = next_page; - params.product = product; - params.query = query; - params.status = status; - params.page_size = page_size; - let response = match block_on(api.get_data_deletion_requests_with_http_info(params)) { + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.run_historical_job_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -14376,17 +14528,17 @@ fn test_v2_get_data_deletion_requests( world.response.code = response.status.as_u16(); } -fn test_v2_cancel_data_deletion_request( +fn test_v2_convert_job_result_to_signal( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_data_deletion + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let id = serde_json::from_value(_parameters.get("id").unwrap().clone()).unwrap(); - let response = match block_on(api.cancel_data_deletion_request_with_http_info(id)) { + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.convert_job_result_to_signal_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -14404,13 +14556,14 @@ fn test_v2_cancel_data_deletion_request( world.response.code = response.status.as_u16(); } -fn test_v2_get_domain_allowlist(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_delete_historical_job(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_domain_allowlist + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let response = match block_on(api.get_domain_allowlist_with_http_info()) { + let job_id = serde_json::from_value(_parameters.get("job_id").unwrap().clone()).unwrap(); + let response = match block_on(api.delete_historical_job_with_http_info(job_id)) { Ok(response) => response, Err(error) => { return match error { @@ -14428,14 +14581,14 @@ fn test_v2_get_domain_allowlist(world: &mut DatadogWorld, _parameters: &HashMap< world.response.code = response.status.as_u16(); } -fn test_v2_patch_domain_allowlist(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_get_historical_job(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_domain_allowlist + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.patch_domain_allowlist_with_http_info(body)) { + let job_id = serde_json::from_value(_parameters.get("job_id").unwrap().clone()).unwrap(); + let response = match block_on(api.get_historical_job_with_http_info(job_id)) { Ok(response) => response, Err(error) => { return match error { @@ -14453,14 +14606,14 @@ fn test_v2_patch_domain_allowlist(world: &mut DatadogWorld, _parameters: &HashMa world.response.code = response.status.as_u16(); } -fn test_v2_create_dora_deployment(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_cancel_historical_job(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_dora_metrics + .v2_api_security_monitoring .as_ref() .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_dora_deployment_with_http_info(body)) { + let job_id = serde_json::from_value(_parameters.get("job_id").unwrap().clone()).unwrap(); + let response = match block_on(api.cancel_historical_job_with_http_info(job_id)) { Ok(response) => response, Err(error) => { return match error { @@ -14478,14 +14631,34 @@ fn test_v2_create_dora_deployment(world: &mut DatadogWorld, _parameters: &HashMa world.response.code = response.status.as_u16(); } -fn test_v2_create_dora_incident(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_container_images(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_dora_metrics + .v2_api_container_images .as_ref() .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_dora_incident_with_http_info(body)) { + let filter_tags = _parameters + .get("filter[tags]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let group_by = _parameters + .get("group_by") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let sort = _parameters + .get("sort") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_size = _parameters + .get("page[size]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_cursor = _parameters + .get("page[cursor]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_container_images::ListContainerImagesOptionalParams::default(); + params.filter_tags = filter_tags; + params.group_by = group_by; + params.sort = sort; + params.page_size = page_size; + params.page_cursor = page_cursor; + let response = match block_on(api.list_container_images_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -14502,31 +14675,92 @@ fn test_v2_create_dora_incident(world: &mut DatadogWorld, _parameters: &HashMap< world.response.object = serde_json::to_value(response.entity).unwrap(); world.response.code = response.status.as_u16(); } +fn test_v2_list_container_images_with_pagination( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { + let api = world + .api_instances + .v2_api_container_images + .as_ref() + .expect("api instance not found"); + let filter_tags = _parameters + .get("filter[tags]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let group_by = _parameters + .get("group_by") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let sort = _parameters + .get("sort") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_size = _parameters + .get("page[size]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_cursor = _parameters + .get("page[cursor]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_container_images::ListContainerImagesOptionalParams::default(); + params.filter_tags = filter_tags; + params.group_by = group_by; + params.sort = sort; + params.page_size = page_size; + params.page_cursor = page_cursor; + let response = api.list_container_images_with_pagination(params); + let mut result = Vec::new(); -fn test_v2_list_downtimes(world: &mut DatadogWorld, _parameters: &HashMap) { + block_on(async { + pin_mut!(response); + + while let Some(resp) = response.next().await { + match resp { + Ok(response) => { + result.push(response); + } + Err(error) => { + return match error { + Error::ResponseError(e) => { + 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(result).unwrap(); + world.response.code = 200; +} + +fn test_v2_list_containers(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_downtimes + .v2_api_containers .as_ref() .expect("api instance not found"); - let current_only = _parameters - .get("current_only") + let filter_tags = _parameters + .get("filter[tags]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let include = _parameters - .get("include") + let group_by = _parameters + .get("group_by") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_offset = _parameters - .get("page[offset]") + let sort = _parameters + .get("sort") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_limit = _parameters - .get("page[limit]") + let page_size = _parameters + .get("page[size]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_downtimes::ListDowntimesOptionalParams::default(); - params.current_only = current_only; - params.include = include; - params.page_offset = page_offset; - params.page_limit = page_limit; - let response = match block_on(api.list_downtimes_with_http_info(params)) { + let page_cursor = _parameters + .get("page[cursor]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_containers::ListContainersOptionalParams::default(); + params.filter_tags = filter_tags; + params.group_by = group_by; + params.sort = sort; + params.page_size = page_size; + params.page_cursor = page_cursor; + let response = match block_on(api.list_containers_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -14543,33 +14777,37 @@ fn test_v2_list_downtimes(world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_downtimes + .v2_api_containers .as_ref() .expect("api instance not found"); - let current_only = _parameters - .get("current_only") + let filter_tags = _parameters + .get("filter[tags]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let include = _parameters - .get("include") + let group_by = _parameters + .get("group_by") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_offset = _parameters - .get("page[offset]") + let sort = _parameters + .get("sort") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_limit = _parameters - .get("page[limit]") + let page_size = _parameters + .get("page[size]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_downtimes::ListDowntimesOptionalParams::default(); - params.current_only = current_only; - params.include = include; - params.page_offset = page_offset; - params.page_limit = page_limit; - let response = api.list_downtimes_with_pagination(params); + let page_cursor = _parameters + .get("page[cursor]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_containers::ListContainersOptionalParams::default(); + params.filter_tags = filter_tags; + params.group_by = group_by; + params.sort = sort; + params.page_size = page_size; + params.page_cursor = page_cursor; + let response = api.list_containers_with_pagination(params); let mut result = Vec::new(); block_on(async { @@ -14597,14 +14835,16 @@ fn test_v2_list_downtimes_with_pagination( world.response.code = 200; } -fn test_v2_create_downtime(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_cost_awscur_configs( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_downtimes + .v2_api_cloud_cost_management .as_ref() .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_downtime_with_http_info(body)) { + let response = match block_on(api.list_cost_awscur_configs_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -14622,15 +14862,17 @@ fn test_v2_create_downtime(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_create_cost_awscur_config( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_downtimes + .v2_api_cloud_cost_management .as_ref() .expect("api instance not found"); - let downtime_id = - serde_json::from_value(_parameters.get("downtime_id").unwrap().clone()).unwrap(); - let response = match block_on(api.cancel_downtime_with_http_info(downtime_id)) { + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.create_cost_awscur_config_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -14648,20 +14890,18 @@ fn test_v2_cancel_downtime(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_delete_cost_awscur_config( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_downtimes + .v2_api_cloud_cost_management .as_ref() .expect("api instance not found"); - let downtime_id = - serde_json::from_value(_parameters.get("downtime_id").unwrap().clone()).unwrap(); - let include = _parameters - .get("include") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_downtimes::GetDowntimeOptionalParams::default(); - params.include = include; - let response = match block_on(api.get_downtime_with_http_info(downtime_id, params)) { + let cloud_account_id = + serde_json::from_value(_parameters.get("cloud_account_id").unwrap().clone()).unwrap(); + let response = match block_on(api.delete_cost_awscur_config_with_http_info(cloud_account_id)) { Ok(response) => response, Err(error) => { return match error { @@ -14679,16 +14919,47 @@ fn test_v2_get_downtime(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_update_cost_awscur_config( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_downtimes + .v2_api_cloud_cost_management .as_ref() .expect("api instance not found"); - let downtime_id = - serde_json::from_value(_parameters.get("downtime_id").unwrap().clone()).unwrap(); + let cloud_account_id = + serde_json::from_value(_parameters.get("cloud_account_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.update_downtime_with_http_info(downtime_id, body)) { + let response = + match block_on(api.update_cost_awscur_config_with_http_info(cloud_account_id, body)) { + 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_v2_list_cost_azure_uc_configs( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { + let api = world + .api_instances + .v2_api_cloud_cost_management + .as_ref() + .expect("api instance not found"); + let response = match block_on(api.list_cost_azure_uc_configs_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -14706,24 +14977,17 @@ fn test_v2_update_downtime(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_create_cost_azure_uc_configs( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_downtimes + .v2_api_cloud_cost_management .as_ref() .expect("api instance not found"); - let monitor_id = - serde_json::from_value(_parameters.get("monitor_id").unwrap().clone()).unwrap(); - let page_offset = _parameters - .get("page[offset]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_limit = _parameters - .get("page[limit]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_downtimes::ListMonitorDowntimesOptionalParams::default(); - params.page_offset = page_offset; - params.page_limit = page_limit; - let response = match block_on(api.list_monitor_downtimes_with_http_info(monitor_id, params)) { + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.create_cost_azure_uc_configs_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -14740,86 +15004,20 @@ fn test_v2_list_monitor_downtimes(world: &mut DatadogWorld, _parameters: &HashMa world.response.object = serde_json::to_value(response.entity).unwrap(); world.response.code = response.status.as_u16(); } -fn test_v2_list_monitor_downtimes_with_pagination( + +fn test_v2_delete_cost_azure_uc_config( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_downtimes - .as_ref() - .expect("api instance not found"); - let monitor_id = - serde_json::from_value(_parameters.get("monitor_id").unwrap().clone()).unwrap(); - let page_offset = _parameters - .get("page[offset]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_limit = _parameters - .get("page[limit]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_downtimes::ListMonitorDowntimesOptionalParams::default(); - params.page_offset = page_offset; - params.page_limit = page_limit; - let response = api.list_monitor_downtimes_with_pagination(monitor_id, params); - let mut result = Vec::new(); - - block_on(async { - pin_mut!(response); - - while let Some(resp) = response.next().await { - match resp { - Ok(response) => { - result.push(response); - } - Err(error) => { - return match error { - Error::ResponseError(e) => { - 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(result).unwrap(); - world.response.code = 200; -} - -fn test_v2_list_events(world: &mut DatadogWorld, _parameters: &HashMap) { - let api = world - .api_instances - .v2_api_events + .v2_api_cloud_cost_management .as_ref() .expect("api instance not found"); - let filter_query = _parameters - .get("filter[query]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_from = _parameters - .get("filter[from]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_to = _parameters - .get("filter[to]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let sort = _parameters - .get("sort") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_cursor = _parameters - .get("page[cursor]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_limit = _parameters - .get("page[limit]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_events::ListEventsOptionalParams::default(); - params.filter_query = filter_query; - params.filter_from = filter_from; - params.filter_to = filter_to; - params.sort = sort; - params.page_cursor = page_cursor; - params.page_limit = page_limit; - let response = match block_on(api.list_events_with_http_info(params)) { + let cloud_account_id = + serde_json::from_value(_parameters.get("cloud_account_id").unwrap().clone()).unwrap(); + let response = match block_on(api.delete_cost_azure_uc_config_with_http_info(cloud_account_id)) + { Ok(response) => response, Err(error) => { return match error { @@ -14836,76 +15034,45 @@ fn test_v2_list_events(world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_events + .v2_api_cloud_cost_management .as_ref() .expect("api instance not found"); - let filter_query = _parameters - .get("filter[query]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_from = _parameters - .get("filter[from]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_to = _parameters - .get("filter[to]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let sort = _parameters - .get("sort") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_cursor = _parameters - .get("page[cursor]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_limit = _parameters - .get("page[limit]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_events::ListEventsOptionalParams::default(); - params.filter_query = filter_query; - params.filter_from = filter_from; - params.filter_to = filter_to; - params.sort = sort; - params.page_cursor = page_cursor; - params.page_limit = page_limit; - let response = api.list_events_with_pagination(params); - let mut result = Vec::new(); - - block_on(async { - pin_mut!(response); - - while let Some(resp) = response.next().await { - match resp { - Ok(response) => { - result.push(response); - } - Err(error) => { - return match error { - Error::ResponseError(e) => { - if let Some(entity) = e.entity { - world.response.object = serde_json::to_value(entity).unwrap(); - } + let cloud_account_id = + serde_json::from_value(_parameters.get("cloud_account_id").unwrap().clone()).unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = + match block_on(api.update_cost_azure_uc_configs_with_http_info(cloud_account_id, body)) { + 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(result).unwrap(); - world.response.code = 200; + }; + world.response.object = serde_json::to_value(response.entity).unwrap(); + world.response.code = response.status.as_u16(); } -fn test_v2_create_event(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_custom_costs_files(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_events + .v2_api_cloud_cost_management .as_ref() .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_event_with_http_info(body)) { + let response = match block_on(api.list_custom_costs_files_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -14923,18 +15090,17 @@ fn test_v2_create_event(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_upload_custom_costs_file( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_events + .v2_api_cloud_cost_management .as_ref() .expect("api instance not found"); - let body = _parameters - .get("body") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_events::SearchEventsOptionalParams::default(); - params.body = body; - let response = match block_on(api.search_events_with_http_info(params)) { + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.upload_custom_costs_file_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -14951,68 +15117,43 @@ fn test_v2_search_events(world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_events + .v2_api_cloud_cost_management .as_ref() .expect("api instance not found"); - let body = _parameters - .get("body") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_events::SearchEventsOptionalParams::default(); - params.body = body; - let response = api.search_events_with_pagination(params); - let mut result = Vec::new(); - - block_on(async { - pin_mut!(response); - - while let Some(resp) = response.next().await { - match resp { - Ok(response) => { - result.push(response); - } - Err(error) => { - return match error { - Error::ResponseError(e) => { - if let Some(entity) = e.entity { - world.response.object = serde_json::to_value(entity).unwrap(); - } - } - _ => panic!("error parsing response: {}", error), - }; + let file_id = serde_json::from_value(_parameters.get("file_id").unwrap().clone()).unwrap(); + let response = match block_on(api.delete_custom_costs_file_with_http_info(file_id)) { + 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(result).unwrap(); - world.response.code = 200; + }; + world.response.object = serde_json::to_value(response.entity).unwrap(); + world.response.code = response.status.as_u16(); } -fn test_v2_list_incidents(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_get_custom_costs_file(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_incidents + .v2_api_cloud_cost_management .as_ref() .expect("api instance not found"); - let include = _parameters - .get("include") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_size = _parameters - .get("page[size]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_offset = _parameters - .get("page[offset]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_incidents::ListIncidentsOptionalParams::default(); - params.include = include; - params.page_size = page_size; - params.page_offset = page_offset; - let response = match block_on(api.list_incidents_with_http_info(params)) { + let file_id = serde_json::from_value(_parameters.get("file_id").unwrap().clone()).unwrap(); + let response = match block_on(api.get_custom_costs_file_with_http_info(file_id)) { Ok(response) => response, Err(error) => { return match error { @@ -15029,64 +15170,17 @@ fn test_v2_list_incidents(world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_incidents + .v2_api_usage_metering .as_ref() .expect("api instance not found"); - let include = _parameters - .get("include") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_size = _parameters - .get("page[size]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_offset = _parameters - .get("page[offset]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_incidents::ListIncidentsOptionalParams::default(); - params.include = include; - params.page_size = page_size; - params.page_offset = page_offset; - let response = api.list_incidents_with_pagination(params); - let mut result = Vec::new(); - - block_on(async { - pin_mut!(response); - - while let Some(resp) = response.next().await { - match resp { - Ok(response) => { - result.push(response); - } - Err(error) => { - return match error { - Error::ResponseError(e) => { - 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(result).unwrap(); - world.response.code = 200; -} - -fn test_v2_create_incident(world: &mut DatadogWorld, _parameters: &HashMap) { - let api = world - .api_instances - .v2_api_incidents - .as_ref() - .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_incident_with_http_info(body)) { + let response = match block_on(api.get_active_billing_dimensions_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -15104,18 +15198,49 @@ fn test_v2_create_incident(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_get_monthly_cost_attribution( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_incidents + .v2_api_usage_metering .as_ref() .expect("api instance not found"); - let include_deleted = _parameters - .get("include_deleted") + let start_month = + serde_json::from_value(_parameters.get("start_month").unwrap().clone()).unwrap(); + let fields = serde_json::from_value(_parameters.get("fields").unwrap().clone()).unwrap(); + let end_month = _parameters + .get("end_month") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_incidents::ListIncidentTypesOptionalParams::default(); - params.include_deleted = include_deleted; - let response = match block_on(api.list_incident_types_with_http_info(params)) { + let sort_direction = _parameters + .get("sort_direction") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let sort_name = _parameters + .get("sort_name") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let tag_breakdown_keys = _parameters + .get("tag_breakdown_keys") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let next_record_id = _parameters + .get("next_record_id") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let include_descendants = _parameters + .get("include_descendants") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = + datadogV2::api_usage_metering::GetMonthlyCostAttributionOptionalParams::default(); + params.end_month = end_month; + params.sort_direction = sort_direction; + params.sort_name = sort_name; + params.tag_breakdown_keys = tag_breakdown_keys; + params.next_record_id = next_record_id; + params.include_descendants = include_descendants; + let response = match block_on(api.get_monthly_cost_attribution_with_http_info( + start_month, + fields, + params, + )) { Ok(response) => response, Err(error) => { return match error { @@ -15133,14 +15258,26 @@ fn test_v2_list_incident_types(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_get_usage_application_security_monitoring( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_incidents + .v2_api_usage_metering .as_ref() .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_incident_type_with_http_info(body)) { + let start_hr = serde_json::from_value(_parameters.get("start_hr").unwrap().clone()).unwrap(); + let end_hr = _parameters + .get("end_hr") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = + datadogV2::api_usage_metering::GetUsageApplicationSecurityMonitoringOptionalParams::default( + ); + params.end_hr = end_hr; + let response = match block_on( + api.get_usage_application_security_monitoring_with_http_info(start_hr, params), + ) { Ok(response) => response, Err(error) => { return match error { @@ -15158,15 +15295,26 @@ fn test_v2_create_incident_type(world: &mut DatadogWorld, _parameters: &HashMap< world.response.code = response.status.as_u16(); } -fn test_v2_delete_incident_type(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_get_billing_dimension_mapping( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_incidents + .v2_api_usage_metering .as_ref() .expect("api instance not found"); - let incident_type_id = - serde_json::from_value(_parameters.get("incident_type_id").unwrap().clone()).unwrap(); - let response = match block_on(api.delete_incident_type_with_http_info(incident_type_id)) { + let filter_month = _parameters + .get("filter[month]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_view = _parameters + .get("filter[view]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = + datadogV2::api_usage_metering::GetBillingDimensionMappingOptionalParams::default(); + params.filter_month = filter_month; + params.filter_view = filter_view; + let response = match block_on(api.get_billing_dimension_mapping_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -15184,15 +15332,20 @@ fn test_v2_delete_incident_type(world: &mut DatadogWorld, _parameters: &HashMap< world.response.code = response.status.as_u16(); } -fn test_v2_get_incident_type(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_get_cost_by_org(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_incidents + .v2_api_usage_metering .as_ref() .expect("api instance not found"); - let incident_type_id = - serde_json::from_value(_parameters.get("incident_type_id").unwrap().clone()).unwrap(); - let response = match block_on(api.get_incident_type_with_http_info(incident_type_id)) { + let start_month = + serde_json::from_value(_parameters.get("start_month").unwrap().clone()).unwrap(); + let end_month = _parameters + .get("end_month") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_usage_metering::GetCostByOrgOptionalParams::default(); + params.end_month = end_month; + let response = match block_on(api.get_cost_by_org_with_http_info(start_month, params)) { Ok(response) => response, Err(error) => { return match error { @@ -15210,16 +15363,41 @@ fn test_v2_get_incident_type(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_get_estimated_cost_by_org( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_incidents + .v2_api_usage_metering .as_ref() .expect("api instance not found"); - let incident_type_id = - serde_json::from_value(_parameters.get("incident_type_id").unwrap().clone()).unwrap(); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.update_incident_type_with_http_info(incident_type_id, body)) { + let view = _parameters + .get("view") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let start_month = _parameters + .get("start_month") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let end_month = _parameters + .get("end_month") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let start_date = _parameters + .get("start_date") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let end_date = _parameters + .get("end_date") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let include_connected_accounts = _parameters + .get("include_connected_accounts") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_usage_metering::GetEstimatedCostByOrgOptionalParams::default(); + params.view = view; + params.start_month = start_month; + params.end_month = end_month; + params.start_date = start_date; + params.end_date = end_date; + params.include_connected_accounts = include_connected_accounts; + let response = match block_on(api.get_estimated_cost_by_org_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -15237,111 +15415,198 @@ fn test_v2_update_incident_type(world: &mut DatadogWorld, _parameters: &HashMap< world.response.code = response.status.as_u16(); } -fn test_v2_search_incidents(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_get_historical_cost_by_org( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_incidents + .v2_api_usage_metering .as_ref() .expect("api instance not found"); - let query = serde_json::from_value(_parameters.get("query").unwrap().clone()).unwrap(); - let include = _parameters - .get("include") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let sort = _parameters - .get("sort") + let start_month = + serde_json::from_value(_parameters.get("start_month").unwrap().clone()).unwrap(); + let view = _parameters + .get("view") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_size = _parameters - .get("page[size]") + let end_month = _parameters + .get("end_month") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_offset = _parameters - .get("page[offset]") + let include_connected_accounts = _parameters + .get("include_connected_accounts") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_incidents::SearchIncidentsOptionalParams::default(); - params.include = include; - params.sort = sort; - params.page_size = page_size; - params.page_offset = page_offset; - let response = match block_on(api.search_incidents_with_http_info(query, 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(); + let mut params = datadogV2::api_usage_metering::GetHistoricalCostByOrgOptionalParams::default(); + params.view = view; + params.end_month = end_month; + params.include_connected_accounts = include_connected_accounts; + let response = + match block_on(api.get_historical_cost_by_org_with_http_info(start_month, 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(); } -fn test_v2_search_incidents_with_pagination( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { + +fn test_v2_get_hourly_usage(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_incidents + .v2_api_usage_metering .as_ref() .expect("api instance not found"); - let query = serde_json::from_value(_parameters.get("query").unwrap().clone()).unwrap(); - let include = _parameters - .get("include") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let sort = _parameters - .get("sort") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_size = _parameters - .get("page[size]") + let filter_timestamp_start = + serde_json::from_value(_parameters.get("filter[timestamp][start]").unwrap().clone()) + .unwrap(); + let filter_product_families = + serde_json::from_value(_parameters.get("filter[product_families]").unwrap().clone()) + .unwrap(); + let filter_timestamp_end = _parameters + .get("filter[timestamp][end]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_offset = _parameters - .get("page[offset]") + let filter_include_descendants = _parameters + .get("filter[include_descendants]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_incidents::SearchIncidentsOptionalParams::default(); - params.include = include; - params.sort = sort; - params.page_size = page_size; - params.page_offset = page_offset; - let response = api.search_incidents_with_pagination(query, params); - let mut result = Vec::new(); + let filter_include_connected_accounts = _parameters + .get("filter[include_connected_accounts]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_include_breakdown = _parameters + .get("filter[include_breakdown]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_versions = _parameters + .get("filter[versions]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_limit = _parameters + .get("page[limit]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_next_record_id = _parameters + .get("page[next_record_id]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_usage_metering::GetHourlyUsageOptionalParams::default(); + params.filter_timestamp_end = filter_timestamp_end; + params.filter_include_descendants = filter_include_descendants; + params.filter_include_connected_accounts = filter_include_connected_accounts; + params.filter_include_breakdown = filter_include_breakdown; + params.filter_versions = filter_versions; + params.page_limit = page_limit; + params.page_next_record_id = page_next_record_id; + let response = match block_on(api.get_hourly_usage_with_http_info( + filter_timestamp_start, + filter_product_families, + 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}"), + }; + } + }; + world.response.object = serde_json::to_value(response.entity).unwrap(); + world.response.code = response.status.as_u16(); +} - block_on(async { - pin_mut!(response); +fn test_v2_get_usage_lambda_traced_invocations( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { + let api = world + .api_instances + .v2_api_usage_metering + .as_ref() + .expect("api instance not found"); + let start_hr = serde_json::from_value(_parameters.get("start_hr").unwrap().clone()).unwrap(); + let end_hr = _parameters + .get("end_hr") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = + datadogV2::api_usage_metering::GetUsageLambdaTracedInvocationsOptionalParams::default(); + params.end_hr = end_hr; + let response = + match block_on(api.get_usage_lambda_traced_invocations_with_http_info(start_hr, 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}"), + }; + } + }; + world.response.object = serde_json::to_value(response.entity).unwrap(); + world.response.code = response.status.as_u16(); +} - while let Some(resp) = response.next().await { - match resp { - Ok(response) => { - result.push(response); - } - Err(error) => { - return match error { - Error::ResponseError(e) => { - if let Some(entity) = e.entity { - world.response.object = serde_json::to_value(entity).unwrap(); - } +fn test_v2_get_usage_observability_pipelines( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { + let api = world + .api_instances + .v2_api_usage_metering + .as_ref() + .expect("api instance not found"); + let start_hr = serde_json::from_value(_parameters.get("start_hr").unwrap().clone()).unwrap(); + let end_hr = _parameters + .get("end_hr") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = + datadogV2::api_usage_metering::GetUsageObservabilityPipelinesOptionalParams::default(); + params.end_hr = end_hr; + let response = + match block_on(api.get_usage_observability_pipelines_with_http_info(start_hr, 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(result).unwrap(); - world.response.code = 200; + }; + world.response.object = serde_json::to_value(response.entity).unwrap(); + world.response.code = response.status.as_u16(); } -fn test_v2_delete_incident(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_get_projected_cost(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_incidents + .v2_api_usage_metering .as_ref() .expect("api instance not found"); - let incident_id = - serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); - let response = match block_on(api.delete_incident_with_http_info(incident_id)) { + let view = _parameters + .get("view") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let include_connected_accounts = _parameters + .get("include_connected_accounts") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_usage_metering::GetProjectedCostOptionalParams::default(); + params.view = view; + params.include_connected_accounts = include_connected_accounts; + let response = match block_on(api.get_projected_cost_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -15359,20 +15624,30 @@ fn test_v2_delete_incident(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_all_csm_agents(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_incidents + .v2_api_csm_agents .as_ref() .expect("api instance not found"); - let incident_id = - serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); - let include = _parameters - .get("include") + let page = _parameters + .get("page") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_incidents::GetIncidentOptionalParams::default(); - params.include = include; - let response = match block_on(api.get_incident_with_http_info(incident_id, params)) { + let size = _parameters + .get("size") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let query = _parameters + .get("query") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let order_direction = _parameters + .get("order_direction") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_csm_agents::ListAllCSMAgentsOptionalParams::default(); + params.page = page; + params.size = size; + params.query = query; + params.order_direction = order_direction; + let response = match block_on(api.list_all_csm_agents_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -15390,21 +15665,33 @@ fn test_v2_get_incident(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_all_csm_serverless_agents( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_incidents + .v2_api_csm_agents .as_ref() .expect("api instance not found"); - let incident_id = - serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let include = _parameters - .get("include") + let page = _parameters + .get("page") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_incidents::UpdateIncidentOptionalParams::default(); - params.include = include; - let response = match block_on(api.update_incident_with_http_info(incident_id, body, params)) { + let size = _parameters + .get("size") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let query = _parameters + .get("query") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let order_direction = _parameters + .get("order_direction") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_csm_agents::ListAllCSMServerlessAgentsOptionalParams::default(); + params.page = page; + params.size = size; + params.query = query; + params.order_direction = order_direction; + let response = match block_on(api.list_all_csm_serverless_agents_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -15422,28 +15709,16 @@ fn test_v2_update_incident(world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_incidents + .v2_api_csm_coverage_analysis .as_ref() .expect("api instance not found"); - let incident_id = - serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); - let include = _parameters - .get("include") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_attachment_type = _parameters - .get("filter[attachment_type]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_incidents::ListIncidentAttachmentsOptionalParams::default(); - params.include = include; - params.filter_attachment_type = filter_attachment_type; - let response = match block_on(api.list_incident_attachments_with_http_info(incident_id, params)) - { + let response = match block_on(api.get_csm_cloud_accounts_coverage_analysis_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -15461,25 +15736,17 @@ fn test_v2_list_incident_attachments( world.response.code = response.status.as_u16(); } -fn test_v2_update_incident_attachments( +fn test_v2_get_csm_hosts_and_containers_coverage_analysis( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_incidents + .v2_api_csm_coverage_analysis .as_ref() .expect("api instance not found"); - let incident_id = - serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let include = _parameters - .get("include") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_incidents::UpdateIncidentAttachmentsOptionalParams::default(); - params.include = include; let response = - match block_on(api.update_incident_attachments_with_http_info(incident_id, body, params)) { + match block_on(api.get_csm_hosts_and_containers_coverage_analysis_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -15497,18 +15764,16 @@ fn test_v2_update_incident_attachments( world.response.code = response.status.as_u16(); } -fn test_v2_list_incident_integrations( +fn test_v2_get_csm_serverless_coverage_analysis( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_incidents + .v2_api_csm_coverage_analysis .as_ref() .expect("api instance not found"); - let incident_id = - serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); - let response = match block_on(api.list_incident_integrations_with_http_info(incident_id)) { + let response = match block_on(api.get_csm_serverless_coverage_analysis_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -15526,54 +15791,49 @@ fn test_v2_list_incident_integrations( world.response.code = response.status.as_u16(); } -fn test_v2_create_incident_integration( +fn test_v2_delete_dashboard_list_items( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_incidents + .v2_api_dashboard_lists .as_ref() .expect("api instance not found"); - let incident_id = - serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); + let dashboard_list_id = + serde_json::from_value(_parameters.get("dashboard_list_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_incident_integration_with_http_info(incident_id, body)) - { - 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 response = + match block_on(api.delete_dashboard_list_items_with_http_info(dashboard_list_id, body)) { + 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(); } -fn test_v2_delete_incident_integration( +fn test_v2_get_dashboard_list_items( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_incidents + .v2_api_dashboard_lists .as_ref() .expect("api instance not found"); - let incident_id = - serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); - let integration_metadata_id = - serde_json::from_value(_parameters.get("integration_metadata_id").unwrap().clone()) - .unwrap(); - let response = match block_on( - api.delete_incident_integration_with_http_info(incident_id, integration_metadata_id), - ) { + let dashboard_list_id = + serde_json::from_value(_parameters.get("dashboard_list_id").unwrap().clone()).unwrap(); + let response = match block_on(api.get_dashboard_list_items_with_http_info(dashboard_list_id)) { Ok(response) => response, Err(error) => { return match error { @@ -15591,23 +15851,80 @@ fn test_v2_delete_incident_integration( world.response.code = response.status.as_u16(); } -fn test_v2_get_incident_integration( +fn test_v2_create_dashboard_list_items( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_incidents + .v2_api_dashboard_lists .as_ref() .expect("api instance not found"); - let incident_id = - serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); - let integration_metadata_id = - serde_json::from_value(_parameters.get("integration_metadata_id").unwrap().clone()) - .unwrap(); - let response = match block_on( - api.get_incident_integration_with_http_info(incident_id, integration_metadata_id), - ) { + let dashboard_list_id = + serde_json::from_value(_parameters.get("dashboard_list_id").unwrap().clone()).unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = + match block_on(api.create_dashboard_list_items_with_http_info(dashboard_list_id, body)) { + 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_v2_update_dashboard_list_items( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { + let api = world + .api_instances + .v2_api_dashboard_lists + .as_ref() + .expect("api instance not found"); + let dashboard_list_id = + serde_json::from_value(_parameters.get("dashboard_list_id").unwrap().clone()).unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = + match block_on(api.update_dashboard_list_items_with_http_info(dashboard_list_id, body)) { + 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_v2_create_data_deletion_request( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { + let api = world + .api_instances + .v2_api_data_deletion + .as_ref() + .expect("api instance not found"); + let product = serde_json::from_value(_parameters.get("product").unwrap().clone()).unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.create_data_deletion_request_with_http_info(product, body)) { Ok(response) => response, Err(error) => { return match error { @@ -15625,26 +15942,37 @@ fn test_v2_get_incident_integration( world.response.code = response.status.as_u16(); } -fn test_v2_update_incident_integration( +fn test_v2_get_data_deletion_requests( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_incidents + .v2_api_data_deletion .as_ref() .expect("api instance not found"); - let incident_id = - serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); - let integration_metadata_id = - serde_json::from_value(_parameters.get("integration_metadata_id").unwrap().clone()) - .unwrap(); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.update_incident_integration_with_http_info( - incident_id, - integration_metadata_id, - body, - )) { + let next_page = _parameters + .get("next_page") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let product = _parameters + .get("product") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let query = _parameters + .get("query") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let status = _parameters + .get("status") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_size = _parameters + .get("page_size") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_data_deletion::GetDataDeletionRequestsOptionalParams::default(); + params.next_page = next_page; + params.product = product; + params.query = query; + params.status = status; + params.page_size = page_size; + let response = match block_on(api.get_data_deletion_requests_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -15662,15 +15990,17 @@ fn test_v2_update_incident_integration( world.response.code = response.status.as_u16(); } -fn test_v2_list_incident_todos(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_cancel_data_deletion_request( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_incidents + .v2_api_data_deletion .as_ref() .expect("api instance not found"); - let incident_id = - serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); - let response = match block_on(api.list_incident_todos_with_http_info(incident_id)) { + let id = serde_json::from_value(_parameters.get("id").unwrap().clone()).unwrap(); + let response = match block_on(api.cancel_data_deletion_request_with_http_info(id)) { Ok(response) => response, Err(error) => { return match error { @@ -15688,16 +16018,13 @@ fn test_v2_list_incident_todos(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_get_domain_allowlist(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_incidents + .v2_api_domain_allowlist .as_ref() .expect("api instance not found"); - let incident_id = - serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_incident_todo_with_http_info(incident_id, body)) { + let response = match block_on(api.get_domain_allowlist_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -15715,16 +16042,14 @@ fn test_v2_create_incident_todo(world: &mut DatadogWorld, _parameters: &HashMap< world.response.code = response.status.as_u16(); } -fn test_v2_delete_incident_todo(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_patch_domain_allowlist(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_incidents + .v2_api_domain_allowlist .as_ref() .expect("api instance not found"); - let incident_id = - serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); - let todo_id = serde_json::from_value(_parameters.get("todo_id").unwrap().clone()).unwrap(); - let response = match block_on(api.delete_incident_todo_with_http_info(incident_id, todo_id)) { + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.patch_domain_allowlist_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -15742,16 +16067,14 @@ fn test_v2_delete_incident_todo(world: &mut DatadogWorld, _parameters: &HashMap< world.response.code = response.status.as_u16(); } -fn test_v2_get_incident_todo(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_create_dora_deployment(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_incidents + .v2_api_dora_metrics .as_ref() .expect("api instance not found"); - let incident_id = - serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); - let todo_id = serde_json::from_value(_parameters.get("todo_id").unwrap().clone()).unwrap(); - let response = match block_on(api.get_incident_todo_with_http_info(incident_id, todo_id)) { + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.create_dora_deployment_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -15769,47 +16092,14 @@ fn test_v2_get_incident_todo(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_create_dora_incident(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_incidents + .v2_api_dora_metrics .as_ref() .expect("api instance not found"); - let incident_id = - serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); - let todo_id = serde_json::from_value(_parameters.get("todo_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = - match block_on(api.update_incident_todo_with_http_info(incident_id, todo_id, body)) { - 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_v2_list_aws_accounts(world: &mut DatadogWorld, _parameters: &HashMap) { - let api = world - .api_instances - .v2_api_aws_integration - .as_ref() - .expect("api instance not found"); - let aws_account_id = _parameters - .get("aws_account_id") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_aws_integration::ListAWSAccountsOptionalParams::default(); - params.aws_account_id = aws_account_id; - let response = match block_on(api.list_aws_accounts_with_http_info(params)) { + let response = match block_on(api.create_dora_incident_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -15827,14 +16117,30 @@ fn test_v2_list_aws_accounts(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_downtimes(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_aws_integration + .v2_api_downtimes .as_ref() .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_aws_account_with_http_info(body)) { + let current_only = _parameters + .get("current_only") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let include = _parameters + .get("include") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_offset = _parameters + .get("page[offset]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_limit = _parameters + .get("page[limit]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_downtimes::ListDowntimesOptionalParams::default(); + params.current_only = current_only; + params.include = include; + params.page_offset = page_offset; + params.page_limit = page_limit; + let response = match block_on(api.list_downtimes_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -15851,42 +16157,68 @@ fn test_v2_create_aws_account(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_downtimes_with_pagination( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_aws_integration + .v2_api_downtimes .as_ref() .expect("api instance not found"); - let aws_account_config_id = - serde_json::from_value(_parameters.get("aws_account_config_id").unwrap().clone()).unwrap(); - let response = match block_on(api.delete_aws_account_with_http_info(aws_account_config_id)) { - 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 current_only = _parameters + .get("current_only") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let include = _parameters + .get("include") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_offset = _parameters + .get("page[offset]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_limit = _parameters + .get("page[limit]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_downtimes::ListDowntimesOptionalParams::default(); + params.current_only = current_only; + params.include = include; + params.page_offset = page_offset; + params.page_limit = page_limit; + let response = api.list_downtimes_with_pagination(params); + let mut result = Vec::new(); + + block_on(async { + pin_mut!(response); + + while let Some(resp) = response.next().await { + match resp { + Ok(response) => { + result.push(response); } - _ => panic!("error parsing response: {error}"), - }; + Err(error) => { + return match error { + Error::ResponseError(e) => { + 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(); + }); + world.response.object = serde_json::to_value(result).unwrap(); + world.response.code = 200; } -fn test_v2_get_aws_account(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_create_downtime(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_aws_integration + .v2_api_downtimes .as_ref() .expect("api instance not found"); - let aws_account_config_id = - serde_json::from_value(_parameters.get("aws_account_config_id").unwrap().clone()).unwrap(); - let response = match block_on(api.get_aws_account_with_http_info(aws_account_config_id)) { + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.create_downtime_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -15904,41 +16236,15 @@ fn test_v2_get_aws_account(world: &mut DatadogWorld, _parameters: &HashMap) { - let api = world - .api_instances - .v2_api_aws_integration - .as_ref() - .expect("api instance not found"); - let aws_account_config_id = - serde_json::from_value(_parameters.get("aws_account_config_id").unwrap().clone()).unwrap(); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = - match block_on(api.update_aws_account_with_http_info(aws_account_config_id, body)) { - 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_v2_list_aws_namespaces(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_cancel_downtime(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_aws_integration + .v2_api_downtimes .as_ref() .expect("api instance not found"); - let response = match block_on(api.list_aws_namespaces_with_http_info()) { + let downtime_id = + serde_json::from_value(_parameters.get("downtime_id").unwrap().clone()).unwrap(); + let response = match block_on(api.cancel_downtime_with_http_info(downtime_id)) { Ok(response) => response, Err(error) => { return match error { @@ -15956,16 +16262,20 @@ fn test_v2_list_aws_namespaces(world: &mut DatadogWorld, _parameters: &HashMap, -) { +fn test_v2_get_downtime(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_aws_integration + .v2_api_downtimes .as_ref() .expect("api instance not found"); - let response = match block_on(api.create_new_aws_external_id_with_http_info()) { + let downtime_id = + serde_json::from_value(_parameters.get("downtime_id").unwrap().clone()).unwrap(); + let include = _parameters + .get("include") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_downtimes::GetDowntimeOptionalParams::default(); + params.include = include; + let response = match block_on(api.get_downtime_with_http_info(downtime_id, params)) { Ok(response) => response, Err(error) => { return match error { @@ -15983,13 +16293,16 @@ fn test_v2_create_new_aws_external_id( world.response.code = response.status.as_u16(); } -fn test_v2_list_aws_logs_services(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_update_downtime(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_aws_logs_integration + .v2_api_downtimes .as_ref() .expect("api instance not found"); - let response = match block_on(api.list_aws_logs_services_with_http_info()) { + let downtime_id = + serde_json::from_value(_parameters.get("downtime_id").unwrap().clone()).unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.update_downtime_with_http_info(downtime_id, body)) { Ok(response) => response, Err(error) => { return match error { @@ -16007,13 +16320,24 @@ fn test_v2_list_aws_logs_services(world: &mut DatadogWorld, _parameters: &HashMa world.response.code = response.status.as_u16(); } -fn test_v2_list_gcpsts_accounts(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_monitor_downtimes(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_gcp_integration + .v2_api_downtimes .as_ref() .expect("api instance not found"); - let response = match block_on(api.list_gcpsts_accounts_with_http_info()) { + let monitor_id = + serde_json::from_value(_parameters.get("monitor_id").unwrap().clone()).unwrap(); + let page_offset = _parameters + .get("page[offset]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_limit = _parameters + .get("page[limit]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_downtimes::ListMonitorDowntimesOptionalParams::default(); + params.page_offset = page_offset; + params.page_limit = page_limit; + let response = match block_on(api.list_monitor_downtimes_with_http_info(monitor_id, params)) { Ok(response) => response, Err(error) => { return match error { @@ -16030,15 +16354,86 @@ fn test_v2_list_gcpsts_accounts(world: &mut DatadogWorld, _parameters: &HashMap< world.response.object = serde_json::to_value(response.entity).unwrap(); world.response.code = response.status.as_u16(); } +fn test_v2_list_monitor_downtimes_with_pagination( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { + let api = world + .api_instances + .v2_api_downtimes + .as_ref() + .expect("api instance not found"); + let monitor_id = + serde_json::from_value(_parameters.get("monitor_id").unwrap().clone()).unwrap(); + let page_offset = _parameters + .get("page[offset]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_limit = _parameters + .get("page[limit]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_downtimes::ListMonitorDowntimesOptionalParams::default(); + params.page_offset = page_offset; + params.page_limit = page_limit; + let response = api.list_monitor_downtimes_with_pagination(monitor_id, params); + let mut result = Vec::new(); + + block_on(async { + pin_mut!(response); + + while let Some(resp) = response.next().await { + match resp { + Ok(response) => { + result.push(response); + } + Err(error) => { + return match error { + Error::ResponseError(e) => { + 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(result).unwrap(); + world.response.code = 200; +} -fn test_v2_create_gcpsts_account(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_events(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_gcp_integration + .v2_api_events .as_ref() .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_gcpsts_account_with_http_info(body)) { + let filter_query = _parameters + .get("filter[query]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_from = _parameters + .get("filter[from]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_to = _parameters + .get("filter[to]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let sort = _parameters + .get("sort") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_cursor = _parameters + .get("page[cursor]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_limit = _parameters + .get("page[limit]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_events::ListEventsOptionalParams::default(); + params.filter_query = filter_query; + params.filter_from = filter_from; + params.filter_to = filter_to; + params.sort = sort; + params.page_cursor = page_cursor; + params.page_limit = page_limit; + let response = match block_on(api.list_events_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -16055,43 +16450,76 @@ fn test_v2_create_gcpsts_account(world: &mut DatadogWorld, _parameters: &HashMap world.response.object = serde_json::to_value(response.entity).unwrap(); world.response.code = response.status.as_u16(); } - -fn test_v2_delete_gcpsts_account(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_events_with_pagination( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_gcp_integration + .v2_api_events .as_ref() .expect("api instance not found"); - let account_id = - serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); - let response = match block_on(api.delete_gcpsts_account_with_http_info(account_id)) { - 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 filter_query = _parameters + .get("filter[query]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_from = _parameters + .get("filter[from]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_to = _parameters + .get("filter[to]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let sort = _parameters + .get("sort") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_cursor = _parameters + .get("page[cursor]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_limit = _parameters + .get("page[limit]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_events::ListEventsOptionalParams::default(); + params.filter_query = filter_query; + params.filter_from = filter_from; + params.filter_to = filter_to; + params.sort = sort; + params.page_cursor = page_cursor; + params.page_limit = page_limit; + let response = api.list_events_with_pagination(params); + let mut result = Vec::new(); + + block_on(async { + pin_mut!(response); + + while let Some(resp) = response.next().await { + match resp { + Ok(response) => { + result.push(response); } - _ => panic!("error parsing response: {error}"), - }; + Err(error) => { + return match error { + Error::ResponseError(e) => { + 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(); + }); + world.response.object = serde_json::to_value(result).unwrap(); + world.response.code = 200; } -fn test_v2_update_gcpsts_account(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_create_event(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_gcp_integration + .v2_api_events .as_ref() .expect("api instance not found"); - let account_id = - serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.update_gcpsts_account_with_http_info(account_id, body)) { + let response = match block_on(api.create_event_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -16109,13 +16537,18 @@ fn test_v2_update_gcpsts_account(world: &mut DatadogWorld, _parameters: &HashMap world.response.code = response.status.as_u16(); } -fn test_v2_get_gcpsts_delegate(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_search_events(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_gcp_integration + .v2_api_events .as_ref() .expect("api instance not found"); - let response = match block_on(api.get_gcpsts_delegate_with_http_info()) { + let body = _parameters + .get("body") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_events::SearchEventsOptionalParams::default(); + params.body = body; + let response = match block_on(api.search_events_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -16132,52 +16565,68 @@ fn test_v2_get_gcpsts_delegate(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_search_events_with_pagination( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_gcp_integration + .v2_api_events .as_ref() .expect("api instance not found"); let body = _parameters .get("body") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_gcp_integration::MakeGCPSTSDelegateOptionalParams::default(); + let mut params = datadogV2::api_events::SearchEventsOptionalParams::default(); params.body = body; - let response = match block_on(api.make_gcpsts_delegate_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(); - } + let response = api.search_events_with_pagination(params); + let mut result = Vec::new(); + + block_on(async { + pin_mut!(response); + + while let Some(resp) = response.next().await { + match resp { + Ok(response) => { + result.push(response); } - _ => panic!("error parsing response: {error}"), - }; + Err(error) => { + return match error { + Error::ResponseError(e) => { + 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(); + }); + world.response.object = serde_json::to_value(result).unwrap(); + world.response.code = 200; } -fn test_v2_get_channel_by_name(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_incidents(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_microsoft_teams_integration + .v2_api_incidents .as_ref() .expect("api instance not found"); - let tenant_name = - serde_json::from_value(_parameters.get("tenant_name").unwrap().clone()).unwrap(); - let team_name = serde_json::from_value(_parameters.get("team_name").unwrap().clone()).unwrap(); - let channel_name = - serde_json::from_value(_parameters.get("channel_name").unwrap().clone()).unwrap(); - let response = match block_on(api.get_channel_by_name_with_http_info( - tenant_name, - team_name, - channel_name, - )) { + let include = _parameters + .get("include") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_size = _parameters + .get("page[size]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_offset = _parameters + .get("page[offset]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_incidents::ListIncidentsOptionalParams::default(); + params.include = include; + params.page_size = page_size; + params.page_offset = page_offset; + let response = match block_on(api.list_incidents_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -16194,27 +16643,64 @@ fn test_v2_get_channel_by_name(world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_microsoft_teams_integration + .v2_api_incidents .as_ref() .expect("api instance not found"); - let tenant_id = _parameters - .get("tenant_id") + let include = _parameters + .get("include") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let name = _parameters - .get("name") + let page_size = _parameters + .get("page[size]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = - datadogV2::api_microsoft_teams_integration::ListTenantBasedHandlesOptionalParams::default(); - params.tenant_id = tenant_id; - params.name = name; - let response = match block_on(api.list_tenant_based_handles_with_http_info(params)) { + let page_offset = _parameters + .get("page[offset]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_incidents::ListIncidentsOptionalParams::default(); + params.include = include; + params.page_size = page_size; + params.page_offset = page_offset; + let response = api.list_incidents_with_pagination(params); + let mut result = Vec::new(); + + block_on(async { + pin_mut!(response); + + while let Some(resp) = response.next().await { + match resp { + Ok(response) => { + result.push(response); + } + Err(error) => { + return match error { + Error::ResponseError(e) => { + 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(result).unwrap(); + world.response.code = 200; +} + +fn test_v2_create_incident(world: &mut DatadogWorld, _parameters: &HashMap) { + let api = world + .api_instances + .v2_api_incidents + .as_ref() + .expect("api instance not found"); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.create_incident_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -16232,17 +16718,18 @@ fn test_v2_list_tenant_based_handles( world.response.code = response.status.as_u16(); } -fn test_v2_create_tenant_based_handle( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_list_incident_types(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_microsoft_teams_integration + .v2_api_incidents .as_ref() .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_tenant_based_handle_with_http_info(body)) { + let include_deleted = _parameters + .get("include_deleted") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_incidents::ListIncidentTypesOptionalParams::default(); + params.include_deleted = include_deleted; + let response = match block_on(api.list_incident_types_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -16260,17 +16747,14 @@ fn test_v2_create_tenant_based_handle( world.response.code = response.status.as_u16(); } -fn test_v2_delete_tenant_based_handle( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_create_incident_type(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_microsoft_teams_integration + .v2_api_incidents .as_ref() .expect("api instance not found"); - let handle_id = serde_json::from_value(_parameters.get("handle_id").unwrap().clone()).unwrap(); - let response = match block_on(api.delete_tenant_based_handle_with_http_info(handle_id)) { + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.create_incident_type_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -16288,14 +16772,15 @@ fn test_v2_delete_tenant_based_handle( world.response.code = response.status.as_u16(); } -fn test_v2_get_tenant_based_handle(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_delete_incident_type(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_microsoft_teams_integration + .v2_api_incidents .as_ref() .expect("api instance not found"); - let handle_id = serde_json::from_value(_parameters.get("handle_id").unwrap().clone()).unwrap(); - let response = match block_on(api.get_tenant_based_handle_with_http_info(handle_id)) { + let incident_type_id = + serde_json::from_value(_parameters.get("incident_type_id").unwrap().clone()).unwrap(); + let response = match block_on(api.delete_incident_type_with_http_info(incident_type_id)) { Ok(response) => response, Err(error) => { return match error { @@ -16313,18 +16798,15 @@ fn test_v2_get_tenant_based_handle(world: &mut DatadogWorld, _parameters: &HashM world.response.code = response.status.as_u16(); } -fn test_v2_update_tenant_based_handle( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_get_incident_type(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_microsoft_teams_integration + .v2_api_incidents .as_ref() .expect("api instance not found"); - let handle_id = serde_json::from_value(_parameters.get("handle_id").unwrap().clone()).unwrap(); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.update_tenant_based_handle_with_http_info(handle_id, body)) { + let incident_type_id = + serde_json::from_value(_parameters.get("incident_type_id").unwrap().clone()).unwrap(); + let response = match block_on(api.get_incident_type_with_http_info(incident_type_id)) { Ok(response) => response, Err(error) => { return match error { @@ -16342,13 +16824,16 @@ fn test_v2_update_tenant_based_handle( world.response.code = response.status.as_u16(); } -fn test_v2_list_opsgenie_services(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_update_incident_type(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_opsgenie_integration + .v2_api_incidents .as_ref() .expect("api instance not found"); - let response = match block_on(api.list_opsgenie_services_with_http_info()) { + let incident_type_id = + serde_json::from_value(_parameters.get("incident_type_id").unwrap().clone()).unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.update_incident_type_with_http_info(incident_type_id, body)) { Ok(response) => response, Err(error) => { return match error { @@ -16366,14 +16851,31 @@ fn test_v2_list_opsgenie_services(world: &mut DatadogWorld, _parameters: &HashMa world.response.code = response.status.as_u16(); } -fn test_v2_create_opsgenie_service(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_search_incidents(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_opsgenie_integration + .v2_api_incidents .as_ref() .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_opsgenie_service_with_http_info(body)) { + let query = serde_json::from_value(_parameters.get("query").unwrap().clone()).unwrap(); + let include = _parameters + .get("include") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let sort = _parameters + .get("sort") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_size = _parameters + .get("page[size]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_offset = _parameters + .get("page[offset]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_incidents::SearchIncidentsOptionalParams::default(); + params.include = include; + params.sort = sort; + params.page_size = page_size; + params.page_offset = page_offset; + let response = match block_on(api.search_incidents_with_http_info(query, params)) { Ok(response) => response, Err(error) => { return match error { @@ -16390,43 +16892,70 @@ fn test_v2_create_opsgenie_service(world: &mut DatadogWorld, _parameters: &HashM world.response.object = serde_json::to_value(response.entity).unwrap(); world.response.code = response.status.as_u16(); } - -fn test_v2_delete_opsgenie_service(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_search_incidents_with_pagination( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_opsgenie_integration + .v2_api_incidents .as_ref() .expect("api instance not found"); - let integration_service_id = - serde_json::from_value(_parameters.get("integration_service_id").unwrap().clone()).unwrap(); - let response = - match block_on(api.delete_opsgenie_service_with_http_info(integration_service_id)) { - 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 = serde_json::from_value(_parameters.get("query").unwrap().clone()).unwrap(); + let include = _parameters + .get("include") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let sort = _parameters + .get("sort") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_size = _parameters + .get("page[size]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_offset = _parameters + .get("page[offset]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_incidents::SearchIncidentsOptionalParams::default(); + params.include = include; + params.sort = sort; + params.page_size = page_size; + params.page_offset = page_offset; + let response = api.search_incidents_with_pagination(query, params); + let mut result = Vec::new(); + + block_on(async { + pin_mut!(response); + + while let Some(resp) = response.next().await { + match resp { + Ok(response) => { + result.push(response); + } + Err(error) => { + return match error { + Error::ResponseError(e) => { + 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(); + } + }); + world.response.object = serde_json::to_value(result).unwrap(); + world.response.code = 200; } -fn test_v2_get_opsgenie_service(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_delete_incident(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_opsgenie_integration + .v2_api_incidents .as_ref() .expect("api instance not found"); - let integration_service_id = - serde_json::from_value(_parameters.get("integration_service_id").unwrap().clone()).unwrap(); - let response = match block_on(api.get_opsgenie_service_with_http_info(integration_service_id)) { + let incident_id = + serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); + let response = match block_on(api.delete_incident_with_http_info(incident_id)) { Ok(response) => response, Err(error) => { return match error { @@ -16444,44 +16973,52 @@ fn test_v2_get_opsgenie_service(world: &mut DatadogWorld, _parameters: &HashMap< world.response.code = response.status.as_u16(); } -fn test_v2_update_opsgenie_service(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_get_incident(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_opsgenie_integration + .v2_api_incidents .as_ref() .expect("api instance not found"); - let integration_service_id = - serde_json::from_value(_parameters.get("integration_service_id").unwrap().clone()).unwrap(); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = - match block_on(api.update_opsgenie_service_with_http_info(integration_service_id, body)) { - 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 incident_id = + serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); + let include = _parameters + .get("include") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_incidents::GetIncidentOptionalParams::default(); + params.include = include; + let response = match block_on(api.get_incident_with_http_info(incident_id, 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(); } -fn test_v2_list_cloudflare_accounts( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_update_incident(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_cloudflare_integration + .v2_api_incidents .as_ref() .expect("api instance not found"); - let response = match block_on(api.list_cloudflare_accounts_with_http_info()) { + let incident_id = + serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let include = _parameters + .get("include") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_incidents::UpdateIncidentOptionalParams::default(); + params.include = include; + let response = match block_on(api.update_incident_with_http_info(incident_id, body, params)) { Ok(response) => response, Err(error) => { return match error { @@ -16499,17 +17036,28 @@ fn test_v2_list_cloudflare_accounts( world.response.code = response.status.as_u16(); } -fn test_v2_create_cloudflare_account( +fn test_v2_list_incident_attachments( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_cloudflare_integration + .v2_api_incidents .as_ref() .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_cloudflare_account_with_http_info(body)) { + let incident_id = + serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); + let include = _parameters + .get("include") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_attachment_type = _parameters + .get("filter[attachment_type]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_incidents::ListIncidentAttachmentsOptionalParams::default(); + params.include = include; + params.filter_attachment_type = filter_attachment_type; + let response = match block_on(api.list_incident_attachments_with_http_info(incident_id, params)) + { Ok(response) => response, Err(error) => { return match error { @@ -16527,18 +17075,54 @@ fn test_v2_create_cloudflare_account( world.response.code = response.status.as_u16(); } -fn test_v2_delete_cloudflare_account( +fn test_v2_update_incident_attachments( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_cloudflare_integration + .v2_api_incidents .as_ref() .expect("api instance not found"); - let account_id = - serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); - let response = match block_on(api.delete_cloudflare_account_with_http_info(account_id)) { + let incident_id = + serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let include = _parameters + .get("include") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_incidents::UpdateIncidentAttachmentsOptionalParams::default(); + params.include = include; + let response = + match block_on(api.update_incident_attachments_with_http_info(incident_id, body, 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}"), + }; + } + }; + world.response.object = serde_json::to_value(response.entity).unwrap(); + world.response.code = response.status.as_u16(); +} + +fn test_v2_list_incident_integrations( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { + let api = world + .api_instances + .v2_api_incidents + .as_ref() + .expect("api instance not found"); + let incident_id = + serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); + let response = match block_on(api.list_incident_integrations_with_http_info(incident_id)) { Ok(response) => response, Err(error) => { return match error { @@ -16556,45 +17140,20 @@ fn test_v2_delete_cloudflare_account( world.response.code = response.status.as_u16(); } -fn test_v2_get_cloudflare_account(world: &mut DatadogWorld, _parameters: &HashMap) { - let api = world - .api_instances - .v2_api_cloudflare_integration - .as_ref() - .expect("api instance not found"); - let account_id = - serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); - let response = match block_on(api.get_cloudflare_account_with_http_info(account_id)) { - 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_v2_update_cloudflare_account( +fn test_v2_create_incident_integration( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_cloudflare_integration + .v2_api_incidents .as_ref() .expect("api instance not found"); - let account_id = - serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); + let incident_id = + serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.update_cloudflare_account_with_http_info(account_id, body)) { + let response = match block_on(api.create_incident_integration_with_http_info(incident_id, body)) + { Ok(response) => response, Err(error) => { return match error { @@ -16612,13 +17171,23 @@ fn test_v2_update_cloudflare_account( world.response.code = response.status.as_u16(); } -fn test_v2_list_confluent_account(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_delete_incident_integration( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_confluent_cloud + .v2_api_incidents .as_ref() .expect("api instance not found"); - let response = match block_on(api.list_confluent_account_with_http_info()) { + let incident_id = + serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); + let integration_metadata_id = + serde_json::from_value(_parameters.get("integration_metadata_id").unwrap().clone()) + .unwrap(); + let response = match block_on( + api.delete_incident_integration_with_http_info(incident_id, integration_metadata_id), + ) { Ok(response) => response, Err(error) => { return match error { @@ -16636,17 +17205,23 @@ fn test_v2_list_confluent_account(world: &mut DatadogWorld, _parameters: &HashMa world.response.code = response.status.as_u16(); } -fn test_v2_create_confluent_account( +fn test_v2_get_incident_integration( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_confluent_cloud + .v2_api_incidents .as_ref() .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_confluent_account_with_http_info(body)) { + let incident_id = + serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); + let integration_metadata_id = + serde_json::from_value(_parameters.get("integration_metadata_id").unwrap().clone()) + .unwrap(); + let response = match block_on( + api.get_incident_integration_with_http_info(incident_id, integration_metadata_id), + ) { Ok(response) => response, Err(error) => { return match error { @@ -16664,18 +17239,26 @@ fn test_v2_create_confluent_account( world.response.code = response.status.as_u16(); } -fn test_v2_delete_confluent_account( +fn test_v2_update_incident_integration( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_confluent_cloud + .v2_api_incidents .as_ref() .expect("api instance not found"); - let account_id = - serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); - let response = match block_on(api.delete_confluent_account_with_http_info(account_id)) { + let incident_id = + serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); + let integration_metadata_id = + serde_json::from_value(_parameters.get("integration_metadata_id").unwrap().clone()) + .unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.update_incident_integration_with_http_info( + incident_id, + integration_metadata_id, + body, + )) { Ok(response) => response, Err(error) => { return match error { @@ -16693,15 +17276,15 @@ fn test_v2_delete_confluent_account( world.response.code = response.status.as_u16(); } -fn test_v2_get_confluent_account(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_incident_todos(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_confluent_cloud + .v2_api_incidents .as_ref() .expect("api instance not found"); - let account_id = - serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); - let response = match block_on(api.get_confluent_account_with_http_info(account_id)) { + let incident_id = + serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); + let response = match block_on(api.list_incident_todos_with_http_info(incident_id)) { Ok(response) => response, Err(error) => { return match error { @@ -16719,19 +17302,16 @@ fn test_v2_get_confluent_account(world: &mut DatadogWorld, _parameters: &HashMap world.response.code = response.status.as_u16(); } -fn test_v2_update_confluent_account( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_create_incident_todo(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_confluent_cloud + .v2_api_incidents .as_ref() .expect("api instance not found"); - let account_id = - serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); + let incident_id = + serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.update_confluent_account_with_http_info(account_id, body)) { + let response = match block_on(api.create_incident_todo_with_http_info(incident_id, body)) { Ok(response) => response, Err(error) => { return match error { @@ -16749,15 +17329,16 @@ fn test_v2_update_confluent_account( world.response.code = response.status.as_u16(); } -fn test_v2_list_confluent_resource(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_delete_incident_todo(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_confluent_cloud + .v2_api_incidents .as_ref() .expect("api instance not found"); - let account_id = - serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); - let response = match block_on(api.list_confluent_resource_with_http_info(account_id)) { + let incident_id = + serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); + let todo_id = serde_json::from_value(_parameters.get("todo_id").unwrap().clone()).unwrap(); + let response = match block_on(api.delete_incident_todo_with_http_info(incident_id, todo_id)) { Ok(response) => response, Err(error) => { return match error { @@ -16775,19 +17356,16 @@ fn test_v2_list_confluent_resource(world: &mut DatadogWorld, _parameters: &HashM world.response.code = response.status.as_u16(); } -fn test_v2_create_confluent_resource( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_get_incident_todo(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_confluent_cloud + .v2_api_incidents .as_ref() .expect("api instance not found"); - let account_id = - serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_confluent_resource_with_http_info(account_id, body)) { + let incident_id = + serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); + let todo_id = serde_json::from_value(_parameters.get("todo_id").unwrap().clone()).unwrap(); + let response = match block_on(api.get_incident_todo_with_http_info(incident_id, todo_id)) { Ok(response) => response, Err(error) => { return match error { @@ -16805,84 +17383,18 @@ fn test_v2_create_confluent_resource( world.response.code = response.status.as_u16(); } -fn test_v2_delete_confluent_resource( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { - let api = world - .api_instances - .v2_api_confluent_cloud - .as_ref() - .expect("api instance not found"); - let account_id = - serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); - let resource_id = - serde_json::from_value(_parameters.get("resource_id").unwrap().clone()).unwrap(); - let response = - match block_on(api.delete_confluent_resource_with_http_info(account_id, resource_id)) { - 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_v2_get_confluent_resource(world: &mut DatadogWorld, _parameters: &HashMap) { - let api = world - .api_instances - .v2_api_confluent_cloud - .as_ref() - .expect("api instance not found"); - let account_id = - serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); - let resource_id = - serde_json::from_value(_parameters.get("resource_id").unwrap().clone()).unwrap(); - let response = - match block_on(api.get_confluent_resource_with_http_info(account_id, resource_id)) { - 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_v2_update_confluent_resource( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_update_incident_todo(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_confluent_cloud + .v2_api_incidents .as_ref() .expect("api instance not found"); - let account_id = - serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); - let resource_id = - serde_json::from_value(_parameters.get("resource_id").unwrap().clone()).unwrap(); + let incident_id = + serde_json::from_value(_parameters.get("incident_id").unwrap().clone()).unwrap(); + let todo_id = serde_json::from_value(_parameters.get("todo_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); let response = - match block_on(api.update_confluent_resource_with_http_info(account_id, resource_id, body)) - { + match block_on(api.update_incident_todo_with_http_info(incident_id, todo_id, body)) { Ok(response) => response, Err(error) => { return match error { @@ -16900,13 +17412,18 @@ fn test_v2_update_confluent_resource( world.response.code = response.status.as_u16(); } -fn test_v2_list_fastly_accounts(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_aws_accounts(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_fastly_integration + .v2_api_aws_integration .as_ref() .expect("api instance not found"); - let response = match block_on(api.list_fastly_accounts_with_http_info()) { + let aws_account_id = _parameters + .get("aws_account_id") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_aws_integration::ListAWSAccountsOptionalParams::default(); + params.aws_account_id = aws_account_id; + let response = match block_on(api.list_aws_accounts_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -16924,14 +17441,14 @@ fn test_v2_list_fastly_accounts(world: &mut DatadogWorld, _parameters: &HashMap< world.response.code = response.status.as_u16(); } -fn test_v2_create_fastly_account(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_create_aws_account(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_fastly_integration + .v2_api_aws_integration .as_ref() .expect("api instance not found"); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_fastly_account_with_http_info(body)) { + let response = match block_on(api.create_aws_account_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -16949,15 +17466,15 @@ fn test_v2_create_fastly_account(world: &mut DatadogWorld, _parameters: &HashMap world.response.code = response.status.as_u16(); } -fn test_v2_delete_fastly_account(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_delete_aws_account(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_fastly_integration + .v2_api_aws_integration .as_ref() .expect("api instance not found"); - let account_id = - serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); - let response = match block_on(api.delete_fastly_account_with_http_info(account_id)) { + let aws_account_config_id = + serde_json::from_value(_parameters.get("aws_account_config_id").unwrap().clone()).unwrap(); + let response = match block_on(api.delete_aws_account_with_http_info(aws_account_config_id)) { Ok(response) => response, Err(error) => { return match error { @@ -16975,15 +17492,15 @@ fn test_v2_delete_fastly_account(world: &mut DatadogWorld, _parameters: &HashMap world.response.code = response.status.as_u16(); } -fn test_v2_get_fastly_account(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_get_aws_account(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_fastly_integration + .v2_api_aws_integration .as_ref() .expect("api instance not found"); - let account_id = - serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); - let response = match block_on(api.get_fastly_account_with_http_info(account_id)) { + let aws_account_config_id = + serde_json::from_value(_parameters.get("aws_account_config_id").unwrap().clone()).unwrap(); + let response = match block_on(api.get_aws_account_with_http_info(aws_account_config_id)) { Ok(response) => response, Err(error) => { return match error { @@ -17001,16 +17518,41 @@ fn test_v2_get_fastly_account(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_update_aws_account(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_fastly_integration + .v2_api_aws_integration .as_ref() .expect("api instance not found"); - let account_id = - serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); + let aws_account_config_id = + serde_json::from_value(_parameters.get("aws_account_config_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.update_fastly_account_with_http_info(account_id, body)) { + let response = + match block_on(api.update_aws_account_with_http_info(aws_account_config_id, body)) { + 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_v2_list_aws_namespaces(world: &mut DatadogWorld, _parameters: &HashMap) { + let api = world + .api_instances + .v2_api_aws_integration + .as_ref() + .expect("api instance not found"); + let response = match block_on(api.list_aws_namespaces_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -17028,15 +17570,16 @@ fn test_v2_update_fastly_account(world: &mut DatadogWorld, _parameters: &HashMap world.response.code = response.status.as_u16(); } -fn test_v2_list_fastly_services(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_create_new_aws_external_id( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_fastly_integration + .v2_api_aws_integration .as_ref() .expect("api instance not found"); - let account_id = - serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); - let response = match block_on(api.list_fastly_services_with_http_info(account_id)) { + let response = match block_on(api.create_new_aws_external_id_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -17054,16 +17597,13 @@ fn test_v2_list_fastly_services(world: &mut DatadogWorld, _parameters: &HashMap< world.response.code = response.status.as_u16(); } -fn test_v2_create_fastly_service(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_aws_logs_services(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_fastly_integration + .v2_api_aws_logs_integration .as_ref() .expect("api instance not found"); - let account_id = - serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_fastly_service_with_http_info(account_id, body)) { + let response = match block_on(api.list_aws_logs_services_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -17081,18 +17621,13 @@ fn test_v2_create_fastly_service(world: &mut DatadogWorld, _parameters: &HashMap world.response.code = response.status.as_u16(); } -fn test_v2_delete_fastly_service(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_gcpsts_accounts(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_fastly_integration + .v2_api_gcp_integration .as_ref() .expect("api instance not found"); - let account_id = - serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); - let service_id = - serde_json::from_value(_parameters.get("service_id").unwrap().clone()).unwrap(); - let response = match block_on(api.delete_fastly_service_with_http_info(account_id, service_id)) - { + let response = match block_on(api.list_gcpsts_accounts_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -17110,17 +17645,14 @@ fn test_v2_delete_fastly_service(world: &mut DatadogWorld, _parameters: &HashMap world.response.code = response.status.as_u16(); } -fn test_v2_get_fastly_service(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_create_gcpsts_account(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_fastly_integration + .v2_api_gcp_integration .as_ref() .expect("api instance not found"); - let account_id = - serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); - let service_id = - serde_json::from_value(_parameters.get("service_id").unwrap().clone()).unwrap(); - let response = match block_on(api.get_fastly_service_with_http_info(account_id, service_id)) { + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.create_gcpsts_account_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -17138,43 +17670,15 @@ fn test_v2_get_fastly_service(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_delete_gcpsts_account(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_fastly_integration + .v2_api_gcp_integration .as_ref() .expect("api instance not found"); let account_id = serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); - let service_id = - serde_json::from_value(_parameters.get("service_id").unwrap().clone()).unwrap(); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = - match block_on(api.update_fastly_service_with_http_info(account_id, service_id, body)) { - 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_v2_list_okta_accounts(world: &mut DatadogWorld, _parameters: &HashMap) { - let api = world - .api_instances - .v2_api_okta_integration - .as_ref() - .expect("api instance not found"); - let response = match block_on(api.list_okta_accounts_with_http_info()) { + let response = match block_on(api.delete_gcpsts_account_with_http_info(account_id)) { Ok(response) => response, Err(error) => { return match error { @@ -17192,14 +17696,16 @@ fn test_v2_list_okta_accounts(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_update_gcpsts_account(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_okta_integration + .v2_api_gcp_integration .as_ref() .expect("api instance not found"); + let account_id = + serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_okta_account_with_http_info(body)) { + let response = match block_on(api.update_gcpsts_account_with_http_info(account_id, body)) { Ok(response) => response, Err(error) => { return match error { @@ -17217,15 +17723,13 @@ fn test_v2_create_okta_account(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_get_gcpsts_delegate(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_okta_integration + .v2_api_gcp_integration .as_ref() .expect("api instance not found"); - let account_id = - serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); - let response = match block_on(api.delete_okta_account_with_http_info(account_id)) { + let response = match block_on(api.get_gcpsts_delegate_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -17243,15 +17747,18 @@ fn test_v2_delete_okta_account(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_make_gcpsts_delegate(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_okta_integration + .v2_api_gcp_integration .as_ref() .expect("api instance not found"); - let account_id = - serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); - let response = match block_on(api.get_okta_account_with_http_info(account_id)) { + let body = _parameters + .get("body") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_gcp_integration::MakeGCPSTSDelegateOptionalParams::default(); + params.body = body; + let response = match block_on(api.make_gcpsts_delegate_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -17269,16 +17776,22 @@ fn test_v2_get_okta_account(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_get_channel_by_name(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_okta_integration + .v2_api_microsoft_teams_integration .as_ref() .expect("api instance not found"); - let account_id = - serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.update_okta_account_with_http_info(account_id, body)) { + let tenant_name = + serde_json::from_value(_parameters.get("tenant_name").unwrap().clone()).unwrap(); + let team_name = serde_json::from_value(_parameters.get("team_name").unwrap().clone()).unwrap(); + let channel_name = + serde_json::from_value(_parameters.get("channel_name").unwrap().clone()).unwrap(); + let response = match block_on(api.get_channel_by_name_with_http_info( + tenant_name, + team_name, + channel_name, + )) { Ok(response) => response, Err(error) => { return match error { @@ -17296,13 +17809,26 @@ fn test_v2_update_okta_account(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_tenant_based_handles( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_ip_allowlist + .v2_api_microsoft_teams_integration .as_ref() .expect("api instance not found"); - let response = match block_on(api.get_ip_allowlist_with_http_info()) { + let tenant_id = _parameters + .get("tenant_id") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let name = _parameters + .get("name") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = + datadogV2::api_microsoft_teams_integration::ListTenantBasedHandlesOptionalParams::default(); + params.tenant_id = tenant_id; + params.name = name; + let response = match block_on(api.list_tenant_based_handles_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -17320,14 +17846,17 @@ fn test_v2_get_ip_allowlist(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_create_tenant_based_handle( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_ip_allowlist + .v2_api_microsoft_teams_integration .as_ref() .expect("api instance not found"); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.update_ip_allowlist_with_http_info(body)) { + let response = match block_on(api.create_tenant_based_handle_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -17345,23 +17874,17 @@ fn test_v2_update_ip_allowlist(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_delete_tenant_based_handle( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_logs + .v2_api_microsoft_teams_integration .as_ref() .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let content_encoding = _parameters - .get("Content-Encoding") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let ddtags = _parameters - .get("ddtags") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_logs::SubmitLogOptionalParams::default(); - params.content_encoding = content_encoding; - params.ddtags = ddtags; - let response = match block_on(api.submit_log_with_http_info(body, params)) { + let handle_id = serde_json::from_value(_parameters.get("handle_id").unwrap().clone()).unwrap(); + let response = match block_on(api.delete_tenant_based_handle_with_http_info(handle_id)) { Ok(response) => response, Err(error) => { return match error { @@ -17379,14 +17902,14 @@ fn test_v2_submit_log(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_get_tenant_based_handle(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_logs + .v2_api_microsoft_teams_integration .as_ref() .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.aggregate_logs_with_http_info(body)) { + let handle_id = serde_json::from_value(_parameters.get("handle_id").unwrap().clone()).unwrap(); + let response = match block_on(api.get_tenant_based_handle_with_http_info(handle_id)) { Ok(response) => response, Err(error) => { return match error { @@ -17404,46 +17927,18 @@ fn test_v2_aggregate_logs(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_update_tenant_based_handle( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_logs + .v2_api_microsoft_teams_integration .as_ref() .expect("api instance not found"); - let filter_query = _parameters - .get("filter[query]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_indexes = _parameters - .get("filter[indexes]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_from = _parameters - .get("filter[from]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_to = _parameters - .get("filter[to]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_storage_tier = _parameters - .get("filter[storage_tier]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let sort = _parameters - .get("sort") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_cursor = _parameters - .get("page[cursor]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_limit = _parameters - .get("page[limit]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_logs::ListLogsGetOptionalParams::default(); - params.filter_query = filter_query; - params.filter_indexes = filter_indexes; - params.filter_from = filter_from; - params.filter_to = filter_to; - params.filter_storage_tier = filter_storage_tier; - params.sort = sort; - params.page_cursor = page_cursor; - params.page_limit = page_limit; - let response = match block_on(api.list_logs_get_with_http_info(params)) { + let handle_id = serde_json::from_value(_parameters.get("handle_id").unwrap().clone()).unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.update_tenant_based_handle_with_http_info(handle_id, body)) { Ok(response) => response, Err(error) => { return match error { @@ -17460,88 +17955,39 @@ fn test_v2_list_logs_get(world: &mut DatadogWorld, _parameters: &HashMap, -) { + +fn test_v2_list_opsgenie_services(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_logs + .v2_api_opsgenie_integration .as_ref() .expect("api instance not found"); - let filter_query = _parameters - .get("filter[query]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_indexes = _parameters - .get("filter[indexes]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_from = _parameters - .get("filter[from]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_to = _parameters - .get("filter[to]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_storage_tier = _parameters - .get("filter[storage_tier]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let sort = _parameters - .get("sort") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_cursor = _parameters - .get("page[cursor]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_limit = _parameters - .get("page[limit]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_logs::ListLogsGetOptionalParams::default(); - params.filter_query = filter_query; - params.filter_indexes = filter_indexes; - params.filter_from = filter_from; - params.filter_to = filter_to; - params.filter_storage_tier = filter_storage_tier; - params.sort = sort; - params.page_cursor = page_cursor; - params.page_limit = page_limit; - let response = api.list_logs_get_with_pagination(params); - let mut result = Vec::new(); - - block_on(async { - pin_mut!(response); - - while let Some(resp) = response.next().await { - match resp { - Ok(response) => { - result.push(response); - } - Err(error) => { - return match error { - Error::ResponseError(e) => { - if let Some(entity) = e.entity { - world.response.object = serde_json::to_value(entity).unwrap(); - } - } - _ => panic!("error parsing response: {}", error), - }; + let response = match block_on(api.list_opsgenie_services_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(); + } } - } + _ => panic!("error parsing response: {error}"), + }; } - }); - world.response.object = serde_json::to_value(result).unwrap(); - world.response.code = 200; + }; + world.response.object = serde_json::to_value(response.entity).unwrap(); + world.response.code = response.status.as_u16(); } -fn test_v2_list_logs(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_create_opsgenie_service(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_logs + .v2_api_opsgenie_integration .as_ref() .expect("api instance not found"); - let body = _parameters - .get("body") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_logs::ListLogsOptionalParams::default(); - params.body = body; - let response = match block_on(api.list_logs_with_http_info(params)) { + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.create_opsgenie_service_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -17558,55 +18004,43 @@ fn test_v2_list_logs(world: &mut DatadogWorld, _parameters: &HashMap, -) { + +fn test_v2_delete_opsgenie_service(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_logs + .v2_api_opsgenie_integration .as_ref() .expect("api instance not found"); - let body = _parameters - .get("body") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_logs::ListLogsOptionalParams::default(); - params.body = body; - let response = api.list_logs_with_pagination(params); - let mut result = Vec::new(); - - block_on(async { - pin_mut!(response); - - while let Some(resp) = response.next().await { - match resp { - Ok(response) => { - result.push(response); - } - Err(error) => { - return match error { - Error::ResponseError(e) => { - if let Some(entity) = e.entity { - world.response.object = serde_json::to_value(entity).unwrap(); - } + let integration_service_id = + serde_json::from_value(_parameters.get("integration_service_id").unwrap().clone()).unwrap(); + let response = + match block_on(api.delete_opsgenie_service_with_http_info(integration_service_id)) { + 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(result).unwrap(); - world.response.code = 200; + }; + world.response.object = serde_json::to_value(response.entity).unwrap(); + world.response.code = response.status.as_u16(); } -fn test_v2_get_logs_archive_order(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_get_opsgenie_service(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_logs_archives + .v2_api_opsgenie_integration .as_ref() .expect("api instance not found"); - let response = match block_on(api.get_logs_archive_order_with_http_info()) { + let integration_service_id = + serde_json::from_value(_parameters.get("integration_service_id").unwrap().clone()).unwrap(); + let response = match block_on(api.get_opsgenie_service_with_http_info(integration_service_id)) { Ok(response) => response, Err(error) => { return match error { @@ -17624,17 +18058,44 @@ fn test_v2_get_logs_archive_order(world: &mut DatadogWorld, _parameters: &HashMa world.response.code = response.status.as_u16(); } -fn test_v2_update_logs_archive_order( +fn test_v2_update_opsgenie_service(world: &mut DatadogWorld, _parameters: &HashMap) { + let api = world + .api_instances + .v2_api_opsgenie_integration + .as_ref() + .expect("api instance not found"); + let integration_service_id = + serde_json::from_value(_parameters.get("integration_service_id").unwrap().clone()).unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = + match block_on(api.update_opsgenie_service_with_http_info(integration_service_id, body)) { + 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_v2_list_cloudflare_accounts( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_logs_archives + .v2_api_cloudflare_integration .as_ref() .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.update_logs_archive_order_with_http_info(body)) { + let response = match block_on(api.list_cloudflare_accounts_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -17652,13 +18113,17 @@ fn test_v2_update_logs_archive_order( world.response.code = response.status.as_u16(); } -fn test_v2_list_logs_archives(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_create_cloudflare_account( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_logs_archives + .v2_api_cloudflare_integration .as_ref() .expect("api instance not found"); - let response = match block_on(api.list_logs_archives_with_http_info()) { + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.create_cloudflare_account_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -17676,14 +18141,18 @@ fn test_v2_list_logs_archives(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_delete_cloudflare_account( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_logs_archives + .v2_api_cloudflare_integration .as_ref() .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_logs_archive_with_http_info(body)) { + let account_id = + serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); + let response = match block_on(api.delete_cloudflare_account_with_http_info(account_id)) { Ok(response) => response, Err(error) => { return match error { @@ -17701,15 +18170,15 @@ fn test_v2_create_logs_archive(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_get_cloudflare_account(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_logs_archives + .v2_api_cloudflare_integration .as_ref() .expect("api instance not found"); - let archive_id = - serde_json::from_value(_parameters.get("archive_id").unwrap().clone()).unwrap(); - let response = match block_on(api.delete_logs_archive_with_http_info(archive_id)) { + let account_id = + serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); + let response = match block_on(api.get_cloudflare_account_with_http_info(account_id)) { Ok(response) => response, Err(error) => { return match error { @@ -17727,15 +18196,19 @@ fn test_v2_delete_logs_archive(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_update_cloudflare_account( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_logs_archives + .v2_api_cloudflare_integration .as_ref() .expect("api instance not found"); - let archive_id = - serde_json::from_value(_parameters.get("archive_id").unwrap().clone()).unwrap(); - let response = match block_on(api.get_logs_archive_with_http_info(archive_id)) { + let account_id = + serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.update_cloudflare_account_with_http_info(account_id, body)) { Ok(response) => response, Err(error) => { return match error { @@ -17753,16 +18226,13 @@ fn test_v2_get_logs_archive(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_confluent_account(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_logs_archives + .v2_api_confluent_cloud .as_ref() .expect("api instance not found"); - let archive_id = - serde_json::from_value(_parameters.get("archive_id").unwrap().clone()).unwrap(); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.update_logs_archive_with_http_info(archive_id, body)) { + let response = match block_on(api.list_confluent_account_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -17780,19 +18250,17 @@ fn test_v2_update_logs_archive(world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_logs_archives + .v2_api_confluent_cloud .as_ref() .expect("api instance not found"); - let archive_id = - serde_json::from_value(_parameters.get("archive_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.remove_role_from_archive_with_http_info(archive_id, body)) { + let response = match block_on(api.create_confluent_account_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -17810,17 +18278,20 @@ fn test_v2_remove_role_from_archive( world.response.code = response.status.as_u16(); } -fn test_v2_list_archive_read_roles(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_delete_confluent_account( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_logs_archives + .v2_api_confluent_cloud .as_ref() .expect("api instance not found"); - let archive_id = - serde_json::from_value(_parameters.get("archive_id").unwrap().clone()).unwrap(); - let response = match block_on(api.list_archive_read_roles_with_http_info(archive_id)) { - Ok(response) => response, - Err(error) => { + let account_id = + serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); + let response = match block_on(api.delete_confluent_account_with_http_info(account_id)) { + Ok(response) => response, + Err(error) => { return match error { Error::ResponseError(e) => { world.response.code = e.status.as_u16(); @@ -17836,19 +18307,45 @@ fn test_v2_list_archive_read_roles(world: &mut DatadogWorld, _parameters: &HashM world.response.code = response.status.as_u16(); } -fn test_v2_add_read_role_to_archive( +fn test_v2_get_confluent_account(world: &mut DatadogWorld, _parameters: &HashMap) { + let api = world + .api_instances + .v2_api_confluent_cloud + .as_ref() + .expect("api instance not found"); + let account_id = + serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); + let response = match block_on(api.get_confluent_account_with_http_info(account_id)) { + 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_v2_update_confluent_account( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_logs_archives + .v2_api_confluent_cloud .as_ref() .expect("api instance not found"); - let archive_id = - serde_json::from_value(_parameters.get("archive_id").unwrap().clone()).unwrap(); + let account_id = + serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.add_read_role_to_archive_with_http_info(archive_id, body)) { + let response = match block_on(api.update_confluent_account_with_http_info(account_id, body)) { Ok(response) => response, Err(error) => { return match error { @@ -17866,16 +18363,15 @@ fn test_v2_add_read_role_to_archive( world.response.code = response.status.as_u16(); } -fn test_v2_list_logs_custom_destinations( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_list_confluent_resource(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_logs_custom_destinations + .v2_api_confluent_cloud .as_ref() .expect("api instance not found"); - let response = match block_on(api.list_logs_custom_destinations_with_http_info()) { + let account_id = + serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); + let response = match block_on(api.list_confluent_resource_with_http_info(account_id)) { Ok(response) => response, Err(error) => { return match error { @@ -17893,17 +18389,19 @@ fn test_v2_list_logs_custom_destinations( world.response.code = response.status.as_u16(); } -fn test_v2_create_logs_custom_destination( +fn test_v2_create_confluent_resource( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_logs_custom_destinations + .v2_api_confluent_cloud .as_ref() .expect("api instance not found"); + let account_id = + serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_logs_custom_destination_with_http_info(body)) { + let response = match block_on(api.create_confluent_resource_with_http_info(account_id, body)) { Ok(response) => response, Err(error) => { return match error { @@ -17921,19 +18419,21 @@ fn test_v2_create_logs_custom_destination( world.response.code = response.status.as_u16(); } -fn test_v2_delete_logs_custom_destination( +fn test_v2_delete_confluent_resource( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_logs_custom_destinations + .v2_api_confluent_cloud .as_ref() .expect("api instance not found"); - let custom_destination_id = - serde_json::from_value(_parameters.get("custom_destination_id").unwrap().clone()).unwrap(); + let account_id = + serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); + let resource_id = + serde_json::from_value(_parameters.get("resource_id").unwrap().clone()).unwrap(); let response = - match block_on(api.delete_logs_custom_destination_with_http_info(custom_destination_id)) { + match block_on(api.delete_confluent_resource_with_http_info(account_id, resource_id)) { Ok(response) => response, Err(error) => { return match error { @@ -17951,19 +18451,18 @@ fn test_v2_delete_logs_custom_destination( world.response.code = response.status.as_u16(); } -fn test_v2_get_logs_custom_destination( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_get_confluent_resource(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_logs_custom_destinations + .v2_api_confluent_cloud .as_ref() .expect("api instance not found"); - let custom_destination_id = - serde_json::from_value(_parameters.get("custom_destination_id").unwrap().clone()).unwrap(); + let account_id = + serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); + let resource_id = + serde_json::from_value(_parameters.get("resource_id").unwrap().clone()).unwrap(); let response = - match block_on(api.get_logs_custom_destination_with_http_info(custom_destination_id)) { + match block_on(api.get_confluent_resource_with_http_info(account_id, resource_id)) { Ok(response) => response, Err(error) => { return match error { @@ -17981,21 +18480,47 @@ fn test_v2_get_logs_custom_destination( world.response.code = response.status.as_u16(); } -fn test_v2_update_logs_custom_destination( +fn test_v2_update_confluent_resource( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_logs_custom_destinations + .v2_api_confluent_cloud .as_ref() .expect("api instance not found"); - let custom_destination_id = - serde_json::from_value(_parameters.get("custom_destination_id").unwrap().clone()).unwrap(); + let account_id = + serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); + let resource_id = + serde_json::from_value(_parameters.get("resource_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on( - api.update_logs_custom_destination_with_http_info(custom_destination_id, body), - ) { + let response = + match block_on(api.update_confluent_resource_with_http_info(account_id, resource_id, body)) + { + 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_v2_list_fastly_accounts(world: &mut DatadogWorld, _parameters: &HashMap) { + let api = world + .api_instances + .v2_api_fastly_integration + .as_ref() + .expect("api instance not found"); + let response = match block_on(api.list_fastly_accounts_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -18013,13 +18538,14 @@ fn test_v2_update_logs_custom_destination( world.response.code = response.status.as_u16(); } -fn test_v2_list_logs_metrics(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_create_fastly_account(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_logs_metrics + .v2_api_fastly_integration .as_ref() .expect("api instance not found"); - let response = match block_on(api.list_logs_metrics_with_http_info()) { + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.create_fastly_account_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -18037,14 +18563,15 @@ fn test_v2_list_logs_metrics(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_delete_fastly_account(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_logs_metrics + .v2_api_fastly_integration .as_ref() .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_logs_metric_with_http_info(body)) { + let account_id = + serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); + let response = match block_on(api.delete_fastly_account_with_http_info(account_id)) { Ok(response) => response, Err(error) => { return match error { @@ -18062,14 +18589,15 @@ fn test_v2_create_logs_metric(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_get_fastly_account(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_logs_metrics + .v2_api_fastly_integration .as_ref() .expect("api instance not found"); - let metric_id = serde_json::from_value(_parameters.get("metric_id").unwrap().clone()).unwrap(); - let response = match block_on(api.delete_logs_metric_with_http_info(metric_id)) { + let account_id = + serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); + let response = match block_on(api.get_fastly_account_with_http_info(account_id)) { Ok(response) => response, Err(error) => { return match error { @@ -18087,14 +18615,16 @@ fn test_v2_delete_logs_metric(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_update_fastly_account(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_logs_metrics + .v2_api_fastly_integration .as_ref() .expect("api instance not found"); - let metric_id = serde_json::from_value(_parameters.get("metric_id").unwrap().clone()).unwrap(); - let response = match block_on(api.get_logs_metric_with_http_info(metric_id)) { + let account_id = + serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.update_fastly_account_with_http_info(account_id, body)) { Ok(response) => response, Err(error) => { return match error { @@ -18112,15 +18642,42 @@ fn test_v2_get_logs_metric(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_fastly_services(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_logs_metrics + .v2_api_fastly_integration .as_ref() .expect("api instance not found"); - let metric_id = serde_json::from_value(_parameters.get("metric_id").unwrap().clone()).unwrap(); + let account_id = + serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); + let response = match block_on(api.list_fastly_services_with_http_info(account_id)) { + 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_v2_create_fastly_service(world: &mut DatadogWorld, _parameters: &HashMap) { + let api = world + .api_instances + .v2_api_fastly_integration + .as_ref() + .expect("api instance not found"); + let account_id = + serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.update_logs_metric_with_http_info(metric_id, body)) { + let response = match block_on(api.create_fastly_service_with_http_info(account_id, body)) { Ok(response) => response, Err(error) => { return match error { @@ -18138,50 +18695,18 @@ fn test_v2_update_logs_metric(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_delete_fastly_service(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_metrics + .v2_api_fastly_integration .as_ref() .expect("api instance not found"); - let filter_configured = _parameters - .get("filter[configured]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_tags_configured = _parameters - .get("filter[tags_configured]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_metric_type = _parameters - .get("filter[metric_type]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_include_percentiles = _parameters - .get("filter[include_percentiles]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_queried = _parameters - .get("filter[queried]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_tags = _parameters - .get("filter[tags]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let window_seconds = _parameters - .get("window[seconds]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_size = _parameters - .get("page[size]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_cursor = _parameters - .get("page[cursor]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_metrics::ListTagConfigurationsOptionalParams::default(); - params.filter_configured = filter_configured; - params.filter_tags_configured = filter_tags_configured; - params.filter_metric_type = filter_metric_type; - params.filter_include_percentiles = filter_include_percentiles; - params.filter_queried = filter_queried; - params.filter_tags = filter_tags; - params.window_seconds = window_seconds; - params.page_size = page_size; - params.page_cursor = page_cursor; - let response = match block_on(api.list_tag_configurations_with_http_info(params)) { + let account_id = + serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); + let service_id = + serde_json::from_value(_parameters.get("service_id").unwrap().clone()).unwrap(); + let response = match block_on(api.delete_fastly_service_with_http_info(account_id, service_id)) + { Ok(response) => response, Err(error) => { return match error { @@ -18198,91 +18723,18 @@ fn test_v2_list_tag_configurations(world: &mut DatadogWorld, _parameters: &HashM world.response.object = serde_json::to_value(response.entity).unwrap(); world.response.code = response.status.as_u16(); } -fn test_v2_list_tag_configurations_with_pagination( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { + +fn test_v2_get_fastly_service(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_metrics + .v2_api_fastly_integration .as_ref() .expect("api instance not found"); - let filter_configured = _parameters - .get("filter[configured]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_tags_configured = _parameters - .get("filter[tags_configured]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_metric_type = _parameters - .get("filter[metric_type]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_include_percentiles = _parameters - .get("filter[include_percentiles]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_queried = _parameters - .get("filter[queried]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_tags = _parameters - .get("filter[tags]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let window_seconds = _parameters - .get("window[seconds]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_size = _parameters - .get("page[size]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_cursor = _parameters - .get("page[cursor]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_metrics::ListTagConfigurationsOptionalParams::default(); - params.filter_configured = filter_configured; - params.filter_tags_configured = filter_tags_configured; - params.filter_metric_type = filter_metric_type; - params.filter_include_percentiles = filter_include_percentiles; - params.filter_queried = filter_queried; - params.filter_tags = filter_tags; - params.window_seconds = window_seconds; - params.page_size = page_size; - params.page_cursor = page_cursor; - let response = api.list_tag_configurations_with_pagination(params); - let mut result = Vec::new(); - - block_on(async { - pin_mut!(response); - - while let Some(resp) = response.next().await { - match resp { - Ok(response) => { - result.push(response); - } - Err(error) => { - return match error { - Error::ResponseError(e) => { - 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(result).unwrap(); - world.response.code = 200; -} - -fn test_v2_delete_bulk_tags_metrics_configuration( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { - let api = world - .api_instances - .v2_api_metrics - .as_ref() - .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.delete_bulk_tags_metrics_configuration_with_http_info(body)) { + let account_id = + serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); + let service_id = + serde_json::from_value(_parameters.get("service_id").unwrap().clone()).unwrap(); + let response = match block_on(api.get_fastly_service_with_http_info(account_id, service_id)) { Ok(response) => response, Err(error) => { return match error { @@ -18300,53 +18752,19 @@ fn test_v2_delete_bulk_tags_metrics_configuration( world.response.code = response.status.as_u16(); } -fn test_v2_create_bulk_tags_metrics_configuration( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_update_fastly_service(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_metrics + .v2_api_fastly_integration .as_ref() .expect("api instance not found"); + let account_id = + serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); + let service_id = + serde_json::from_value(_parameters.get("service_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_bulk_tags_metrics_configuration_with_http_info(body)) { - 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_v2_list_active_metric_configurations( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { - let api = world - .api_instances - .v2_api_metrics - .as_ref() - .expect("api instance not found"); - let metric_name = - serde_json::from_value(_parameters.get("metric_name").unwrap().clone()).unwrap(); - let window_seconds = _parameters - .get("window[seconds]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = - datadogV2::api_metrics::ListActiveMetricConfigurationsOptionalParams::default(); - params.window_seconds = window_seconds; let response = - match block_on(api.list_active_metric_configurations_with_http_info(metric_name, params)) { + match block_on(api.update_fastly_service_with_http_info(account_id, service_id, body)) { Ok(response) => response, Err(error) => { return match error { @@ -18364,18 +18782,13 @@ fn test_v2_list_active_metric_configurations( world.response.code = response.status.as_u16(); } -fn test_v2_list_tags_by_metric_name( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_list_okta_accounts(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_metrics + .v2_api_okta_integration .as_ref() .expect("api instance not found"); - let metric_name = - serde_json::from_value(_parameters.get("metric_name").unwrap().clone()).unwrap(); - let response = match block_on(api.list_tags_by_metric_name_with_http_info(metric_name)) { + let response = match block_on(api.list_okta_accounts_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -18393,15 +18806,14 @@ fn test_v2_list_tags_by_metric_name( world.response.code = response.status.as_u16(); } -fn test_v2_list_metric_assets(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_create_okta_account(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_metrics + .v2_api_okta_integration .as_ref() .expect("api instance not found"); - let metric_name = - serde_json::from_value(_parameters.get("metric_name").unwrap().clone()).unwrap(); - let response = match block_on(api.list_metric_assets_with_http_info(metric_name)) { + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.create_okta_account_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -18419,69 +18831,41 @@ fn test_v2_list_metric_assets(world: &mut DatadogWorld, _parameters: &HashMap, -) { +fn test_v2_delete_okta_account(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_metrics + .v2_api_okta_integration .as_ref() .expect("api instance not found"); - let metric_name = - serde_json::from_value(_parameters.get("metric_name").unwrap().clone()).unwrap(); - let filter_groups = _parameters - .get("filter[groups]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_hours_ago = _parameters - .get("filter[hours_ago]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_num_aggregations = _parameters - .get("filter[num_aggregations]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_pct = _parameters - .get("filter[pct]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_timespan_h = _parameters - .get("filter[timespan_h]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_metrics::EstimateMetricsOutputSeriesOptionalParams::default(); - params.filter_groups = filter_groups; - params.filter_hours_ago = filter_hours_ago; - params.filter_num_aggregations = filter_num_aggregations; - params.filter_pct = filter_pct; - params.filter_timespan_h = filter_timespan_h; - let response = - match block_on(api.estimate_metrics_output_series_with_http_info(metric_name, 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(); - } + let account_id = + serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); + let response = match block_on(api.delete_okta_account_with_http_info(account_id)) { + 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(); } -fn test_v2_delete_tag_configuration( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_get_okta_account(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_metrics + .v2_api_okta_integration .as_ref() .expect("api instance not found"); - let metric_name = - serde_json::from_value(_parameters.get("metric_name").unwrap().clone()).unwrap(); - let response = match block_on(api.delete_tag_configuration_with_http_info(metric_name)) { + let account_id = + serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); + let response = match block_on(api.get_okta_account_with_http_info(account_id)) { Ok(response) => response, Err(error) => { return match error { @@ -18499,18 +18883,16 @@ fn test_v2_delete_tag_configuration( world.response.code = response.status.as_u16(); } -fn test_v2_list_tag_configuration_by_name( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_update_okta_account(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_metrics + .v2_api_okta_integration .as_ref() .expect("api instance not found"); - let metric_name = - serde_json::from_value(_parameters.get("metric_name").unwrap().clone()).unwrap(); - let response = match block_on(api.list_tag_configuration_by_name_with_http_info(metric_name)) { + let account_id = + serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.update_okta_account_with_http_info(account_id, body)) { Ok(response) => response, Err(error) => { return match error { @@ -18528,19 +18910,13 @@ fn test_v2_list_tag_configuration_by_name( world.response.code = response.status.as_u16(); } -fn test_v2_update_tag_configuration( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_get_ip_allowlist(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_metrics + .v2_api_ip_allowlist .as_ref() .expect("api instance not found"); - let metric_name = - serde_json::from_value(_parameters.get("metric_name").unwrap().clone()).unwrap(); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.update_tag_configuration_with_http_info(metric_name, body)) { + let response = match block_on(api.get_ip_allowlist_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -18558,19 +18934,14 @@ fn test_v2_update_tag_configuration( world.response.code = response.status.as_u16(); } -fn test_v2_create_tag_configuration( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_update_ip_allowlist(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_metrics + .v2_api_ip_allowlist .as_ref() .expect("api instance not found"); - let metric_name = - serde_json::from_value(_parameters.get("metric_name").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_tag_configuration_with_http_info(metric_name, body)) { + let response = match block_on(api.update_ip_allowlist_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -18588,18 +18959,23 @@ fn test_v2_create_tag_configuration( world.response.code = response.status.as_u16(); } -fn test_v2_list_volumes_by_metric_name( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_submit_log(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_metrics + .v2_api_logs .as_ref() .expect("api instance not found"); - let metric_name = - serde_json::from_value(_parameters.get("metric_name").unwrap().clone()).unwrap(); - let response = match block_on(api.list_volumes_by_metric_name_with_http_info(metric_name)) { + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let content_encoding = _parameters + .get("Content-Encoding") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let ddtags = _parameters + .get("ddtags") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_logs::SubmitLogOptionalParams::default(); + params.content_encoding = content_encoding; + params.ddtags = ddtags; + let response = match block_on(api.submit_log_with_http_info(body, params)) { Ok(response) => response, Err(error) => { return match error { @@ -18617,14 +18993,14 @@ fn test_v2_list_volumes_by_metric_name( world.response.code = response.status.as_u16(); } -fn test_v2_query_scalar_data(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_aggregate_logs(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_metrics + .v2_api_logs .as_ref() .expect("api instance not found"); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.query_scalar_data_with_http_info(body)) { + let response = match block_on(api.aggregate_logs_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -18642,14 +19018,46 @@ fn test_v2_query_scalar_data(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_logs_get(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_metrics + .v2_api_logs .as_ref() .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.query_timeseries_data_with_http_info(body)) { + let filter_query = _parameters + .get("filter[query]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_indexes = _parameters + .get("filter[indexes]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_from = _parameters + .get("filter[from]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_to = _parameters + .get("filter[to]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_storage_tier = _parameters + .get("filter[storage_tier]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let sort = _parameters + .get("sort") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_cursor = _parameters + .get("page[cursor]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_limit = _parameters + .get("page[limit]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_logs::ListLogsGetOptionalParams::default(); + params.filter_query = filter_query; + params.filter_indexes = filter_indexes; + params.filter_from = filter_from; + params.filter_to = filter_to; + params.filter_storage_tier = filter_storage_tier; + params.sort = sort; + params.page_cursor = page_cursor; + params.page_limit = page_limit; + let response = match block_on(api.list_logs_get_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -18666,20 +19074,88 @@ fn test_v2_query_timeseries_data(world: &mut DatadogWorld, _parameters: &HashMap world.response.object = serde_json::to_value(response.entity).unwrap(); world.response.code = response.status.as_u16(); } +fn test_v2_list_logs_get_with_pagination( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { + let api = world + .api_instances + .v2_api_logs + .as_ref() + .expect("api instance not found"); + let filter_query = _parameters + .get("filter[query]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_indexes = _parameters + .get("filter[indexes]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_from = _parameters + .get("filter[from]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_to = _parameters + .get("filter[to]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_storage_tier = _parameters + .get("filter[storage_tier]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let sort = _parameters + .get("sort") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_cursor = _parameters + .get("page[cursor]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_limit = _parameters + .get("page[limit]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_logs::ListLogsGetOptionalParams::default(); + params.filter_query = filter_query; + params.filter_indexes = filter_indexes; + params.filter_from = filter_from; + params.filter_to = filter_to; + params.filter_storage_tier = filter_storage_tier; + params.sort = sort; + params.page_cursor = page_cursor; + params.page_limit = page_limit; + let response = api.list_logs_get_with_pagination(params); + let mut result = Vec::new(); -fn test_v2_submit_metrics(world: &mut DatadogWorld, _parameters: &HashMap) { + block_on(async { + pin_mut!(response); + + while let Some(resp) = response.next().await { + match resp { + Ok(response) => { + result.push(response); + } + Err(error) => { + return match error { + Error::ResponseError(e) => { + 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(result).unwrap(); + world.response.code = 200; +} + +fn test_v2_list_logs(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_metrics + .v2_api_logs .as_ref() .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let content_encoding = _parameters - .get("Content-Encoding") + let body = _parameters + .get("body") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_metrics::SubmitMetricsOptionalParams::default(); - params.content_encoding = content_encoding; - let response = match block_on(api.submit_metrics_with_http_info(body, params)) { + let mut params = datadogV2::api_logs::ListLogsOptionalParams::default(); + params.body = body; + let response = match block_on(api.list_logs_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -18696,17 +19172,55 @@ fn test_v2_submit_metrics(world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_monitors + .v2_api_logs .as_ref() .expect("api instance not found"); - let response = match block_on(api.list_monitor_config_policies_with_http_info()) { + let body = _parameters + .get("body") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_logs::ListLogsOptionalParams::default(); + params.body = body; + let response = api.list_logs_with_pagination(params); + let mut result = Vec::new(); + + block_on(async { + pin_mut!(response); + + while let Some(resp) = response.next().await { + match resp { + Ok(response) => { + result.push(response); + } + Err(error) => { + return match error { + Error::ResponseError(e) => { + 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(result).unwrap(); + world.response.code = 200; +} + +fn test_v2_get_logs_archive_order(world: &mut DatadogWorld, _parameters: &HashMap) { + let api = world + .api_instances + .v2_api_logs_archives + .as_ref() + .expect("api instance not found"); + let response = match block_on(api.get_logs_archive_order_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -18724,17 +19238,17 @@ fn test_v2_list_monitor_config_policies( world.response.code = response.status.as_u16(); } -fn test_v2_create_monitor_config_policy( +fn test_v2_update_logs_archive_order( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_monitors + .v2_api_logs_archives .as_ref() .expect("api instance not found"); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_monitor_config_policy_with_http_info(body)) { + let response = match block_on(api.update_logs_archive_order_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -18752,17 +19266,13 @@ fn test_v2_create_monitor_config_policy( world.response.code = response.status.as_u16(); } -fn test_v2_delete_monitor_config_policy( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_list_logs_archives(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_monitors + .v2_api_logs_archives .as_ref() .expect("api instance not found"); - let policy_id = serde_json::from_value(_parameters.get("policy_id").unwrap().clone()).unwrap(); - let response = match block_on(api.delete_monitor_config_policy_with_http_info(policy_id)) { + let response = match block_on(api.list_logs_archives_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -18780,17 +19290,14 @@ fn test_v2_delete_monitor_config_policy( world.response.code = response.status.as_u16(); } -fn test_v2_get_monitor_config_policy( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_create_logs_archive(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_monitors + .v2_api_logs_archives .as_ref() .expect("api instance not found"); - let policy_id = serde_json::from_value(_parameters.get("policy_id").unwrap().clone()).unwrap(); - let response = match block_on(api.get_monitor_config_policy_with_http_info(policy_id)) { + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.create_logs_archive_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -18808,19 +19315,15 @@ fn test_v2_get_monitor_config_policy( world.response.code = response.status.as_u16(); } -fn test_v2_update_monitor_config_policy( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_delete_logs_archive(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_monitors + .v2_api_logs_archives .as_ref() .expect("api instance not found"); - let policy_id = serde_json::from_value(_parameters.get("policy_id").unwrap().clone()).unwrap(); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.update_monitor_config_policy_with_http_info(policy_id, body)) - { + let archive_id = + serde_json::from_value(_parameters.get("archive_id").unwrap().clone()).unwrap(); + let response = match block_on(api.delete_logs_archive_with_http_info(archive_id)) { Ok(response) => response, Err(error) => { return match error { @@ -18838,30 +19341,15 @@ fn test_v2_update_monitor_config_policy( world.response.code = response.status.as_u16(); } -fn test_v2_list_devices(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_get_logs_archive(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_network_device_monitoring + .v2_api_logs_archives .as_ref() .expect("api instance not found"); - let page_number = _parameters - .get("page[number]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_size = _parameters - .get("page[size]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let sort = _parameters - .get("sort") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_tag = _parameters - .get("filter[tag]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_network_device_monitoring::ListDevicesOptionalParams::default(); - params.page_number = page_number; - params.page_size = page_size; - params.sort = sort; - params.filter_tag = filter_tag; - let response = match block_on(api.list_devices_with_http_info(params)) { + let archive_id = + serde_json::from_value(_parameters.get("archive_id").unwrap().clone()).unwrap(); + let response = match block_on(api.get_logs_archive_with_http_info(archive_id)) { Ok(response) => response, Err(error) => { return match error { @@ -18879,14 +19367,16 @@ fn test_v2_list_devices(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_update_logs_archive(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_network_device_monitoring + .v2_api_logs_archives .as_ref() .expect("api instance not found"); - let device_id = serde_json::from_value(_parameters.get("device_id").unwrap().clone()).unwrap(); - let response = match block_on(api.get_device_with_http_info(device_id)) { + let archive_id = + serde_json::from_value(_parameters.get("archive_id").unwrap().clone()).unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.update_logs_archive_with_http_info(archive_id, body)) { Ok(response) => response, Err(error) => { return match error { @@ -18904,14 +19394,19 @@ fn test_v2_get_device(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_remove_role_from_archive( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_network_device_monitoring + .v2_api_logs_archives .as_ref() .expect("api instance not found"); - let device_id = serde_json::from_value(_parameters.get("device_id").unwrap().clone()).unwrap(); - let response = match block_on(api.get_interfaces_with_http_info(device_id)) { + let archive_id = + serde_json::from_value(_parameters.get("archive_id").unwrap().clone()).unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.remove_role_from_archive_with_http_info(archive_id, body)) { Ok(response) => response, Err(error) => { return match error { @@ -18929,14 +19424,15 @@ fn test_v2_get_interfaces(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_archive_read_roles(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_network_device_monitoring + .v2_api_logs_archives .as_ref() .expect("api instance not found"); - let device_id = serde_json::from_value(_parameters.get("device_id").unwrap().clone()).unwrap(); - let response = match block_on(api.list_device_user_tags_with_http_info(device_id)) { + let archive_id = + serde_json::from_value(_parameters.get("archive_id").unwrap().clone()).unwrap(); + let response = match block_on(api.list_archive_read_roles_with_http_info(archive_id)) { Ok(response) => response, Err(error) => { return match error { @@ -18954,15 +19450,19 @@ fn test_v2_list_device_user_tags(world: &mut DatadogWorld, _parameters: &HashMap world.response.code = response.status.as_u16(); } -fn test_v2_update_device_user_tags(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_add_read_role_to_archive( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_network_device_monitoring + .v2_api_logs_archives .as_ref() .expect("api instance not found"); - let device_id = serde_json::from_value(_parameters.get("device_id").unwrap().clone()).unwrap(); + let archive_id = + serde_json::from_value(_parameters.get("archive_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.update_device_user_tags_with_http_info(device_id, body)) { + let response = match block_on(api.add_read_role_to_archive_with_http_info(archive_id, body)) { Ok(response) => response, Err(error) => { return match error { @@ -18980,13 +19480,16 @@ fn test_v2_update_device_user_tags(world: &mut DatadogWorld, _parameters: &HashM world.response.code = response.status.as_u16(); } -fn test_v2_list_org_configs(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_logs_custom_destinations( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_organizations + .v2_api_logs_custom_destinations .as_ref() .expect("api instance not found"); - let response = match block_on(api.list_org_configs_with_http_info()) { + let response = match block_on(api.list_logs_custom_destinations_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -19004,15 +19507,17 @@ fn test_v2_list_org_configs(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_create_logs_custom_destination( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_organizations + .v2_api_logs_custom_destinations .as_ref() .expect("api instance not found"); - let org_config_name = - serde_json::from_value(_parameters.get("org_config_name").unwrap().clone()).unwrap(); - let response = match block_on(api.get_org_config_with_http_info(org_config_name)) { + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.create_logs_custom_destination_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -19030,74 +19535,81 @@ fn test_v2_get_org_config(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_delete_logs_custom_destination( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_organizations + .v2_api_logs_custom_destinations .as_ref() .expect("api instance not found"); - let org_config_name = - serde_json::from_value(_parameters.get("org_config_name").unwrap().clone()).unwrap(); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.update_org_config_with_http_info(org_config_name, body)) { - 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 custom_destination_id = + serde_json::from_value(_parameters.get("custom_destination_id").unwrap().clone()).unwrap(); + let response = + match block_on(api.delete_logs_custom_destination_with_http_info(custom_destination_id)) { + 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(); } -fn test_v2_upload_idp_metadata(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_get_logs_custom_destination( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_organizations + .v2_api_logs_custom_destinations .as_ref() .expect("api instance not found"); - let idp_file = _parameters.get("idp_file").and_then(|param| { - std::fs::read(format!( - "tests/scenarios/features/v{}/{}", - world.api_version, - param.as_str().unwrap() - )) - .ok() - }); - let mut params = datadogV2::api_organizations::UploadIdPMetadataOptionalParams::default(); - params.idp_file = idp_file; - let response = match block_on(api.upload_idp_metadata_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(); + let custom_destination_id = + serde_json::from_value(_parameters.get("custom_destination_id").unwrap().clone()).unwrap(); + let response = + match block_on(api.get_logs_custom_destination_with_http_info(custom_destination_id)) { + 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(); } -fn test_v2_list_permissions(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_update_logs_custom_destination( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_roles + .v2_api_logs_custom_destinations .as_ref() .expect("api instance not found"); - let response = match block_on(api.list_permissions_with_http_info()) { + let custom_destination_id = + serde_json::from_value(_parameters.get("custom_destination_id").unwrap().clone()).unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on( + api.update_logs_custom_destination_with_http_info(custom_destination_id, body), + ) { Ok(response) => response, Err(error) => { return match error { @@ -19115,34 +19627,13 @@ fn test_v2_list_permissions(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_logs_metrics(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_roles + .v2_api_logs_metrics .as_ref() .expect("api instance not found"); - let page_size = _parameters - .get("page[size]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_number = _parameters - .get("page[number]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let sort = _parameters - .get("sort") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter = _parameters - .get("filter") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_id = _parameters - .get("filter[id]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_roles::ListRolesOptionalParams::default(); - params.page_size = page_size; - params.page_number = page_number; - params.sort = sort; - params.filter = filter; - params.filter_id = filter_id; - let response = match block_on(api.list_roles_with_http_info(params)) { + let response = match block_on(api.list_logs_metrics_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -19160,14 +19651,14 @@ fn test_v2_list_roles(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_create_logs_metric(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_roles + .v2_api_logs_metrics .as_ref() .expect("api instance not found"); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_role_with_http_info(body)) { + let response = match block_on(api.create_logs_metric_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -19185,14 +19676,14 @@ fn test_v2_create_role(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_delete_logs_metric(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_roles + .v2_api_logs_metrics .as_ref() .expect("api instance not found"); - let role_id = serde_json::from_value(_parameters.get("role_id").unwrap().clone()).unwrap(); - let response = match block_on(api.delete_role_with_http_info(role_id)) { + let metric_id = serde_json::from_value(_parameters.get("metric_id").unwrap().clone()).unwrap(); + let response = match block_on(api.delete_logs_metric_with_http_info(metric_id)) { Ok(response) => response, Err(error) => { return match error { @@ -19210,14 +19701,14 @@ fn test_v2_delete_role(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_get_logs_metric(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_roles + .v2_api_logs_metrics .as_ref() .expect("api instance not found"); - let role_id = serde_json::from_value(_parameters.get("role_id").unwrap().clone()).unwrap(); - let response = match block_on(api.get_role_with_http_info(role_id)) { + let metric_id = serde_json::from_value(_parameters.get("metric_id").unwrap().clone()).unwrap(); + let response = match block_on(api.get_logs_metric_with_http_info(metric_id)) { Ok(response) => response, Err(error) => { return match error { @@ -19235,15 +19726,15 @@ fn test_v2_get_role(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_update_logs_metric(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_roles + .v2_api_logs_metrics .as_ref() .expect("api instance not found"); - let role_id = serde_json::from_value(_parameters.get("role_id").unwrap().clone()).unwrap(); + let metric_id = serde_json::from_value(_parameters.get("metric_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.update_role_with_http_info(role_id, body)) { + let response = match block_on(api.update_logs_metric_with_http_info(metric_id, body)) { Ok(response) => response, Err(error) => { return match error { @@ -19261,44 +19752,50 @@ fn test_v2_update_role(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_tag_configurations(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_roles + .v2_api_metrics .as_ref() .expect("api instance not found"); - let role_id = serde_json::from_value(_parameters.get("role_id").unwrap().clone()).unwrap(); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.clone_role_with_http_info(role_id, body)) { - 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_v2_remove_permission_from_role( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { - let api = world - .api_instances - .v2_api_roles - .as_ref() - .expect("api instance not found"); - let role_id = serde_json::from_value(_parameters.get("role_id").unwrap().clone()).unwrap(); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.remove_permission_from_role_with_http_info(role_id, body)) { + let filter_configured = _parameters + .get("filter[configured]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_tags_configured = _parameters + .get("filter[tags_configured]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_metric_type = _parameters + .get("filter[metric_type]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_include_percentiles = _parameters + .get("filter[include_percentiles]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_queried = _parameters + .get("filter[queried]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_tags = _parameters + .get("filter[tags]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let window_seconds = _parameters + .get("window[seconds]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_size = _parameters + .get("page[size]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_cursor = _parameters + .get("page[cursor]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_metrics::ListTagConfigurationsOptionalParams::default(); + params.filter_configured = filter_configured; + params.filter_tags_configured = filter_tags_configured; + params.filter_metric_type = filter_metric_type; + params.filter_include_percentiles = filter_include_percentiles; + params.filter_queried = filter_queried; + params.filter_tags = filter_tags; + params.window_seconds = window_seconds; + params.page_size = page_size; + params.page_cursor = page_cursor; + let response = match block_on(api.list_tag_configurations_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -19315,41 +19812,91 @@ fn test_v2_remove_permission_from_role( world.response.object = serde_json::to_value(response.entity).unwrap(); world.response.code = response.status.as_u16(); } - -fn test_v2_list_role_permissions(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_tag_configurations_with_pagination( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_roles + .v2_api_metrics .as_ref() .expect("api instance not found"); - let role_id = serde_json::from_value(_parameters.get("role_id").unwrap().clone()).unwrap(); - let response = match block_on(api.list_role_permissions_with_http_info(role_id)) { - 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 filter_configured = _parameters + .get("filter[configured]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_tags_configured = _parameters + .get("filter[tags_configured]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_metric_type = _parameters + .get("filter[metric_type]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_include_percentiles = _parameters + .get("filter[include_percentiles]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_queried = _parameters + .get("filter[queried]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_tags = _parameters + .get("filter[tags]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let window_seconds = _parameters + .get("window[seconds]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_size = _parameters + .get("page[size]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_cursor = _parameters + .get("page[cursor]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_metrics::ListTagConfigurationsOptionalParams::default(); + params.filter_configured = filter_configured; + params.filter_tags_configured = filter_tags_configured; + params.filter_metric_type = filter_metric_type; + params.filter_include_percentiles = filter_include_percentiles; + params.filter_queried = filter_queried; + params.filter_tags = filter_tags; + params.window_seconds = window_seconds; + params.page_size = page_size; + params.page_cursor = page_cursor; + let response = api.list_tag_configurations_with_pagination(params); + let mut result = Vec::new(); + + block_on(async { + pin_mut!(response); + + while let Some(resp) = response.next().await { + match resp { + Ok(response) => { + result.push(response); } - _ => panic!("error parsing response: {error}"), - }; + Err(error) => { + return match error { + Error::ResponseError(e) => { + 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(); + }); + world.response.object = serde_json::to_value(result).unwrap(); + world.response.code = 200; } -fn test_v2_add_permission_to_role(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_delete_bulk_tags_metrics_configuration( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_roles + .v2_api_metrics .as_ref() .expect("api instance not found"); - let role_id = serde_json::from_value(_parameters.get("role_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.add_permission_to_role_with_http_info(role_id, body)) { + let response = match block_on(api.delete_bulk_tags_metrics_configuration_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -19367,15 +19914,17 @@ fn test_v2_add_permission_to_role(world: &mut DatadogWorld, _parameters: &HashMa world.response.code = response.status.as_u16(); } -fn test_v2_remove_user_from_role(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_create_bulk_tags_metrics_configuration( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_roles + .v2_api_metrics .as_ref() .expect("api instance not found"); - let role_id = serde_json::from_value(_parameters.get("role_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.remove_user_from_role_with_http_info(role_id, body)) { + let response = match block_on(api.create_bulk_tags_metrics_configuration_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -19393,31 +19942,54 @@ fn test_v2_remove_user_from_role(world: &mut DatadogWorld, _parameters: &HashMap world.response.code = response.status.as_u16(); } -fn test_v2_list_role_users(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_active_metric_configurations( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_roles + .v2_api_metrics .as_ref() .expect("api instance not found"); - let role_id = serde_json::from_value(_parameters.get("role_id").unwrap().clone()).unwrap(); - let page_size = _parameters - .get("page[size]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_number = _parameters - .get("page[number]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let sort = _parameters - .get("sort") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter = _parameters - .get("filter") + let metric_name = + serde_json::from_value(_parameters.get("metric_name").unwrap().clone()).unwrap(); + let window_seconds = _parameters + .get("window[seconds]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_roles::ListRoleUsersOptionalParams::default(); - params.page_size = page_size; - params.page_number = page_number; - params.sort = sort; - params.filter = filter; - let response = match block_on(api.list_role_users_with_http_info(role_id, params)) { + let mut params = + datadogV2::api_metrics::ListActiveMetricConfigurationsOptionalParams::default(); + params.window_seconds = window_seconds; + let response = + match block_on(api.list_active_metric_configurations_with_http_info(metric_name, 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}"), + }; + } + }; + world.response.object = serde_json::to_value(response.entity).unwrap(); + world.response.code = response.status.as_u16(); +} + +fn test_v2_list_tags_by_metric_name( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { + let api = world + .api_instances + .v2_api_metrics + .as_ref() + .expect("api instance not found"); + let metric_name = + serde_json::from_value(_parameters.get("metric_name").unwrap().clone()).unwrap(); + let response = match block_on(api.list_tags_by_metric_name_with_http_info(metric_name)) { Ok(response) => response, Err(error) => { return match error { @@ -19435,15 +20007,15 @@ fn test_v2_list_role_users(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_metric_assets(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_roles + .v2_api_metrics .as_ref() .expect("api instance not found"); - let role_id = serde_json::from_value(_parameters.get("role_id").unwrap().clone()).unwrap(); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.add_user_to_role_with_http_info(role_id, body)) { + let metric_name = + serde_json::from_value(_parameters.get("metric_name").unwrap().clone()).unwrap(); + let response = match block_on(api.list_metric_assets_with_http_info(metric_name)) { Ok(response) => response, Err(error) => { return match error { @@ -19461,488 +20033,69 @@ fn test_v2_add_user_to_role(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_estimate_metrics_output_series( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_metrics .as_ref() .expect("api instance not found"); - let page_limit = _parameters - .get("page[limit]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let snapshot_timestamp = _parameters - .get("snapshot_timestamp") + let metric_name = + serde_json::from_value(_parameters.get("metric_name").unwrap().clone()).unwrap(); + let filter_groups = _parameters + .get("filter[groups]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_cursor = _parameters - .get("page[cursor]") + let filter_hours_ago = _parameters + .get("filter[hours_ago]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_tags = _parameters - .get("filter[tags]") + let filter_num_aggregations = _parameters + .get("filter[num_aggregations]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_evaluation_changed_at = _parameters - .get("filter[evaluation_changed_at]") + let filter_pct = _parameters + .get("filter[pct]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_muted = _parameters - .get("filter[muted]") + let filter_timespan_h = _parameters + .get("filter[timespan_h]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_rule_id = _parameters - .get("filter[rule_id]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_rule_name = _parameters - .get("filter[rule_name]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_resource_type = _parameters - .get("filter[resource_type]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_discovery_timestamp = _parameters - .get("filter[discovery_timestamp]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_evaluation = _parameters - .get("filter[evaluation]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_status = _parameters - .get("filter[status]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_vulnerability_type = _parameters - .get("filter[vulnerability_type]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_security_monitoring::ListFindingsOptionalParams::default(); - params.page_limit = page_limit; - params.snapshot_timestamp = snapshot_timestamp; - params.page_cursor = page_cursor; - params.filter_tags = filter_tags; - params.filter_evaluation_changed_at = filter_evaluation_changed_at; - params.filter_muted = filter_muted; - params.filter_rule_id = filter_rule_id; - params.filter_rule_name = filter_rule_name; - params.filter_resource_type = filter_resource_type; - params.filter_discovery_timestamp = filter_discovery_timestamp; - params.filter_evaluation = filter_evaluation; - params.filter_status = filter_status; - params.filter_vulnerability_type = filter_vulnerability_type; - let response = match block_on(api.list_findings_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(); + let mut params = datadogV2::api_metrics::EstimateMetricsOutputSeriesOptionalParams::default(); + params.filter_groups = filter_groups; + params.filter_hours_ago = filter_hours_ago; + params.filter_num_aggregations = filter_num_aggregations; + params.filter_pct = filter_pct; + params.filter_timespan_h = filter_timespan_h; + let response = + match block_on(api.estimate_metrics_output_series_with_http_info(metric_name, 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(); } -fn test_v2_list_findings_with_pagination( + +fn test_v2_delete_tag_configuration( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_security_monitoring - .as_ref() - .expect("api instance not found"); - let page_limit = _parameters - .get("page[limit]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let snapshot_timestamp = _parameters - .get("snapshot_timestamp") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_cursor = _parameters - .get("page[cursor]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_tags = _parameters - .get("filter[tags]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_evaluation_changed_at = _parameters - .get("filter[evaluation_changed_at]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_muted = _parameters - .get("filter[muted]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_rule_id = _parameters - .get("filter[rule_id]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_rule_name = _parameters - .get("filter[rule_name]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_resource_type = _parameters - .get("filter[resource_type]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_discovery_timestamp = _parameters - .get("filter[discovery_timestamp]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_evaluation = _parameters - .get("filter[evaluation]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_status = _parameters - .get("filter[status]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_vulnerability_type = _parameters - .get("filter[vulnerability_type]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_security_monitoring::ListFindingsOptionalParams::default(); - params.page_limit = page_limit; - params.snapshot_timestamp = snapshot_timestamp; - params.page_cursor = page_cursor; - params.filter_tags = filter_tags; - params.filter_evaluation_changed_at = filter_evaluation_changed_at; - params.filter_muted = filter_muted; - params.filter_rule_id = filter_rule_id; - params.filter_rule_name = filter_rule_name; - params.filter_resource_type = filter_resource_type; - params.filter_discovery_timestamp = filter_discovery_timestamp; - params.filter_evaluation = filter_evaluation; - params.filter_status = filter_status; - params.filter_vulnerability_type = filter_vulnerability_type; - let response = api.list_findings_with_pagination(params); - let mut result = Vec::new(); - - block_on(async { - pin_mut!(response); - - while let Some(resp) = response.next().await { - match resp { - Ok(response) => { - result.push(response); - } - Err(error) => { - return match error { - Error::ResponseError(e) => { - 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(result).unwrap(); - world.response.code = 200; -} - -fn test_v2_mute_findings(world: &mut DatadogWorld, _parameters: &HashMap) { - let api = world - .api_instances - .v2_api_security_monitoring - .as_ref() - .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.mute_findings_with_http_info(body)) { - 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_v2_get_finding(world: &mut DatadogWorld, _parameters: &HashMap) { - let api = world - .api_instances - .v2_api_security_monitoring - .as_ref() - .expect("api instance not found"); - let finding_id = - serde_json::from_value(_parameters.get("finding_id").unwrap().clone()).unwrap(); - let snapshot_timestamp = _parameters - .get("snapshot_timestamp") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_security_monitoring::GetFindingOptionalParams::default(); - params.snapshot_timestamp = snapshot_timestamp; - let response = match block_on(api.get_finding_with_http_info(finding_id, 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}"), - }; - } - }; - world.response.object = serde_json::to_value(response.entity).unwrap(); - world.response.code = response.status.as_u16(); -} - -fn test_v2_list_vulnerable_assets(world: &mut DatadogWorld, _parameters: &HashMap) { - let api = world - .api_instances - .v2_api_security_monitoring - .as_ref() - .expect("api instance not found"); - let page_token = _parameters - .get("page[token]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_number = _parameters - .get("page[number]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_name = _parameters - .get("filter[name]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_type = _parameters - .get("filter[type]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_version_first = _parameters - .get("filter[version.first]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_version_last = _parameters - .get("filter[version.last]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_repository_url = _parameters - .get("filter[repository_url]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_risks_in_production = _parameters - .get("filter[risks.in_production]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_risks_under_attack = _parameters - .get("filter[risks.under_attack]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_risks_is_publicly_accessible = _parameters - .get("filter[risks.is_publicly_accessible]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_risks_has_privileged_access = _parameters - .get("filter[risks.has_privileged_access]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_risks_has_access_to_sensitive_data = _parameters - .get("filter[risks.has_access_to_sensitive_data]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_environments = _parameters - .get("filter[environments]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_arch = _parameters - .get("filter[arch]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_operating_system_name = _parameters - .get("filter[operating_system.name]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_operating_system_version = _parameters - .get("filter[operating_system.version]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = - datadogV2::api_security_monitoring::ListVulnerableAssetsOptionalParams::default(); - params.page_token = page_token; - params.page_number = page_number; - params.filter_name = filter_name; - params.filter_type = filter_type; - params.filter_version_first = filter_version_first; - params.filter_version_last = filter_version_last; - params.filter_repository_url = filter_repository_url; - params.filter_risks_in_production = filter_risks_in_production; - params.filter_risks_under_attack = filter_risks_under_attack; - params.filter_risks_is_publicly_accessible = filter_risks_is_publicly_accessible; - params.filter_risks_has_privileged_access = filter_risks_has_privileged_access; - params.filter_risks_has_access_to_sensitive_data = filter_risks_has_access_to_sensitive_data; - params.filter_environments = filter_environments; - params.filter_arch = filter_arch; - params.filter_operating_system_name = filter_operating_system_name; - params.filter_operating_system_version = filter_operating_system_version; - let response = match block_on(api.list_vulnerable_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}"), - }; - } - }; - world.response.object = serde_json::to_value(response.entity).unwrap(); - world.response.code = response.status.as_u16(); -} - -fn test_v2_list_vulnerabilities(world: &mut DatadogWorld, _parameters: &HashMap) { - let api = world - .api_instances - .v2_api_security_monitoring + .v2_api_metrics .as_ref() - .expect("api instance not found"); - let page_token = _parameters - .get("page[token]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_number = _parameters - .get("page[number]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_type = _parameters - .get("filter[type]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_cvss_base_score_op = _parameters - .get("filter[cvss.base.score][`$op`]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_cvss_base_severity = _parameters - .get("filter[cvss.base.severity]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_cvss_base_vector = _parameters - .get("filter[cvss.base.vector]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_cvss_datadog_score_op = _parameters - .get("filter[cvss.datadog.score][`$op`]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_cvss_datadog_severity = _parameters - .get("filter[cvss.datadog.severity]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_cvss_datadog_vector = _parameters - .get("filter[cvss.datadog.vector]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_status = _parameters - .get("filter[status]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_tool = _parameters - .get("filter[tool]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_library_name = _parameters - .get("filter[library.name]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_library_version = _parameters - .get("filter[library.version]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_advisory_id = _parameters - .get("filter[advisory_id]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_risks_exploitation_probability = _parameters - .get("filter[risks.exploitation_probability]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_risks_poc_exploit_available = _parameters - .get("filter[risks.poc_exploit_available]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_risks_exploit_available = _parameters - .get("filter[risks.exploit_available]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_risks_epss_score_op = _parameters - .get("filter[risks.epss.score][`$op`]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_risks_epss_severity = _parameters - .get("filter[risks.epss.severity]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_language = _parameters - .get("filter[language]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_ecosystem = _parameters - .get("filter[ecosystem]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_code_location_location = _parameters - .get("filter[code_location.location]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_code_location_file_path = _parameters - .get("filter[code_location.file_path]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_code_location_method = _parameters - .get("filter[code_location.method]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_fix_available = _parameters - .get("filter[fix_available]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_repo_digests = _parameters - .get("filter[repo_digests]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_asset_name = _parameters - .get("filter[asset.name]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_asset_type = _parameters - .get("filter[asset.type]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_asset_version_first = _parameters - .get("filter[asset.version.first]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_asset_version_last = _parameters - .get("filter[asset.version.last]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_asset_repository_url = _parameters - .get("filter[asset.repository_url]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_asset_risks_in_production = _parameters - .get("filter[asset.risks.in_production]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_asset_risks_under_attack = _parameters - .get("filter[asset.risks.under_attack]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_asset_risks_is_publicly_accessible = _parameters - .get("filter[asset.risks.is_publicly_accessible]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_asset_risks_has_privileged_access = _parameters - .get("filter[asset.risks.has_privileged_access]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_asset_risks_has_access_to_sensitive_data = _parameters - .get("filter[asset.risks.has_access_to_sensitive_data]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_asset_environments = _parameters - .get("filter[asset.environments]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_asset_arch = _parameters - .get("filter[asset.arch]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_asset_operating_system_name = _parameters - .get("filter[asset.operating_system.name]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_asset_operating_system_version = _parameters - .get("filter[asset.operating_system.version]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = - datadogV2::api_security_monitoring::ListVulnerabilitiesOptionalParams::default(); - params.page_token = page_token; - params.page_number = page_number; - params.filter_type = filter_type; - params.filter_cvss_base_score_op = filter_cvss_base_score_op; - params.filter_cvss_base_severity = filter_cvss_base_severity; - params.filter_cvss_base_vector = filter_cvss_base_vector; - params.filter_cvss_datadog_score_op = filter_cvss_datadog_score_op; - params.filter_cvss_datadog_severity = filter_cvss_datadog_severity; - params.filter_cvss_datadog_vector = filter_cvss_datadog_vector; - params.filter_status = filter_status; - params.filter_tool = filter_tool; - params.filter_library_name = filter_library_name; - params.filter_library_version = filter_library_version; - params.filter_advisory_id = filter_advisory_id; - params.filter_risks_exploitation_probability = filter_risks_exploitation_probability; - params.filter_risks_poc_exploit_available = filter_risks_poc_exploit_available; - params.filter_risks_exploit_available = filter_risks_exploit_available; - params.filter_risks_epss_score_op = filter_risks_epss_score_op; - params.filter_risks_epss_severity = filter_risks_epss_severity; - params.filter_language = filter_language; - params.filter_ecosystem = filter_ecosystem; - params.filter_code_location_location = filter_code_location_location; - params.filter_code_location_file_path = filter_code_location_file_path; - params.filter_code_location_method = filter_code_location_method; - params.filter_fix_available = filter_fix_available; - params.filter_repo_digests = filter_repo_digests; - params.filter_asset_name = filter_asset_name; - params.filter_asset_type = filter_asset_type; - params.filter_asset_version_first = filter_asset_version_first; - params.filter_asset_version_last = filter_asset_version_last; - params.filter_asset_repository_url = filter_asset_repository_url; - params.filter_asset_risks_in_production = filter_asset_risks_in_production; - params.filter_asset_risks_under_attack = filter_asset_risks_under_attack; - params.filter_asset_risks_is_publicly_accessible = filter_asset_risks_is_publicly_accessible; - params.filter_asset_risks_has_privileged_access = filter_asset_risks_has_privileged_access; - params.filter_asset_risks_has_access_to_sensitive_data = - filter_asset_risks_has_access_to_sensitive_data; - params.filter_asset_environments = filter_asset_environments; - params.filter_asset_arch = filter_asset_arch; - params.filter_asset_operating_system_name = filter_asset_operating_system_name; - params.filter_asset_operating_system_version = filter_asset_operating_system_version; - let response = match block_on(api.list_vulnerabilities_with_http_info(params)) { + .expect("api instance not found"); + let metric_name = + serde_json::from_value(_parameters.get("metric_name").unwrap().clone()).unwrap(); + let response = match block_on(api.delete_tag_configuration_with_http_info(metric_name)) { Ok(response) => response, Err(error) => { return match error { @@ -19960,13 +20113,18 @@ fn test_v2_list_vulnerabilities(world: &mut DatadogWorld, _parameters: &HashMap< world.response.code = response.status.as_u16(); } -fn test_v2_list_security_filters(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_tag_configuration_by_name( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_metrics .as_ref() .expect("api instance not found"); - let response = match block_on(api.list_security_filters_with_http_info()) { + let metric_name = + serde_json::from_value(_parameters.get("metric_name").unwrap().clone()).unwrap(); + let response = match block_on(api.list_tag_configuration_by_name_with_http_info(metric_name)) { Ok(response) => response, Err(error) => { return match error { @@ -19984,14 +20142,19 @@ fn test_v2_list_security_filters(world: &mut DatadogWorld, _parameters: &HashMap world.response.code = response.status.as_u16(); } -fn test_v2_create_security_filter(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_update_tag_configuration( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_metrics .as_ref() .expect("api instance not found"); + let metric_name = + serde_json::from_value(_parameters.get("metric_name").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_security_filter_with_http_info(body)) { + let response = match block_on(api.update_tag_configuration_with_http_info(metric_name, body)) { Ok(response) => response, Err(error) => { return match error { @@ -20009,15 +20172,19 @@ fn test_v2_create_security_filter(world: &mut DatadogWorld, _parameters: &HashMa world.response.code = response.status.as_u16(); } -fn test_v2_delete_security_filter(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_create_tag_configuration( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_metrics .as_ref() .expect("api instance not found"); - let security_filter_id = - serde_json::from_value(_parameters.get("security_filter_id").unwrap().clone()).unwrap(); - let response = match block_on(api.delete_security_filter_with_http_info(security_filter_id)) { + let metric_name = + serde_json::from_value(_parameters.get("metric_name").unwrap().clone()).unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.create_tag_configuration_with_http_info(metric_name, body)) { Ok(response) => response, Err(error) => { return match error { @@ -20035,15 +20202,18 @@ fn test_v2_delete_security_filter(world: &mut DatadogWorld, _parameters: &HashMa world.response.code = response.status.as_u16(); } -fn test_v2_get_security_filter(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_volumes_by_metric_name( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_metrics .as_ref() .expect("api instance not found"); - let security_filter_id = - serde_json::from_value(_parameters.get("security_filter_id").unwrap().clone()).unwrap(); - let response = match block_on(api.get_security_filter_with_http_info(security_filter_id)) { + let metric_name = + serde_json::from_value(_parameters.get("metric_name").unwrap().clone()).unwrap(); + let response = match block_on(api.list_volumes_by_metric_name_with_http_info(metric_name)) { Ok(response) => response, Err(error) => { return match error { @@ -20061,44 +20231,96 @@ fn test_v2_get_security_filter(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_query_scalar_data(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_metrics .as_ref() .expect("api instance not found"); - let security_filter_id = - serde_json::from_value(_parameters.get("security_filter_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = - match block_on(api.update_security_filter_with_http_info(security_filter_id, body)) { - 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 response = match block_on(api.query_scalar_data_with_http_info(body)) { + 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(); } -fn test_v2_list_security_monitoring_suppressions( +fn test_v2_query_timeseries_data(world: &mut DatadogWorld, _parameters: &HashMap) { + let api = world + .api_instances + .v2_api_metrics + .as_ref() + .expect("api instance not found"); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.query_timeseries_data_with_http_info(body)) { + 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_v2_submit_metrics(world: &mut DatadogWorld, _parameters: &HashMap) { + let api = world + .api_instances + .v2_api_metrics + .as_ref() + .expect("api instance not found"); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let content_encoding = _parameters + .get("Content-Encoding") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_metrics::SubmitMetricsOptionalParams::default(); + params.content_encoding = content_encoding; + let response = match block_on(api.submit_metrics_with_http_info(body, 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}"), + }; + } + }; + world.response.object = serde_json::to_value(response.entity).unwrap(); + world.response.code = response.status.as_u16(); +} + +fn test_v2_list_monitor_config_policies( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_monitors .as_ref() .expect("api instance not found"); - let response = match block_on(api.list_security_monitoring_suppressions_with_http_info()) { + let response = match block_on(api.list_monitor_config_policies_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -20116,17 +20338,17 @@ fn test_v2_list_security_monitoring_suppressions( world.response.code = response.status.as_u16(); } -fn test_v2_create_security_monitoring_suppression( +fn test_v2_create_monitor_config_policy( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_monitors .as_ref() .expect("api instance not found"); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_security_monitoring_suppression_with_http_info(body)) { + let response = match block_on(api.create_monitor_config_policy_with_http_info(body)) { Ok(response) => response, Err(error) => { return match error { @@ -20144,81 +20366,75 @@ fn test_v2_create_security_monitoring_suppression( world.response.code = response.status.as_u16(); } -fn test_v2_delete_security_monitoring_suppression( +fn test_v2_delete_monitor_config_policy( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_monitors .as_ref() .expect("api instance not found"); - let suppression_id = - serde_json::from_value(_parameters.get("suppression_id").unwrap().clone()).unwrap(); - let response = - match block_on(api.delete_security_monitoring_suppression_with_http_info(suppression_id)) { - 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 policy_id = serde_json::from_value(_parameters.get("policy_id").unwrap().clone()).unwrap(); + let response = match block_on(api.delete_monitor_config_policy_with_http_info(policy_id)) { + 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(); } -fn test_v2_get_security_monitoring_suppression( +fn test_v2_get_monitor_config_policy( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_monitors .as_ref() .expect("api instance not found"); - let suppression_id = - serde_json::from_value(_parameters.get("suppression_id").unwrap().clone()).unwrap(); - let response = - match block_on(api.get_security_monitoring_suppression_with_http_info(suppression_id)) { - 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 policy_id = serde_json::from_value(_parameters.get("policy_id").unwrap().clone()).unwrap(); + let response = match block_on(api.get_monitor_config_policy_with_http_info(policy_id)) { + 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(); } -fn test_v2_update_security_monitoring_suppression( +fn test_v2_update_monitor_config_policy( world: &mut DatadogWorld, _parameters: &HashMap, ) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_monitors .as_ref() .expect("api instance not found"); - let suppression_id = - serde_json::from_value(_parameters.get("suppression_id").unwrap().clone()).unwrap(); + let policy_id = serde_json::from_value(_parameters.get("policy_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on( - api.update_security_monitoring_suppression_with_http_info(suppression_id, body), - ) { + let response = match block_on(api.update_monitor_config_policy_with_http_info(policy_id, body)) + { Ok(response) => response, Err(error) => { return match error { @@ -20236,26 +20452,30 @@ fn test_v2_update_security_monitoring_suppression( world.response.code = response.status.as_u16(); } -fn test_v2_list_security_monitoring_rules( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_list_devices(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_network_device_monitoring .as_ref() .expect("api instance not found"); + let page_number = _parameters + .get("page[number]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); let page_size = _parameters .get("page[size]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_number = _parameters - .get("page[number]") + let sort = _parameters + .get("sort") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = - datadogV2::api_security_monitoring::ListSecurityMonitoringRulesOptionalParams::default(); - params.page_size = page_size; + let filter_tag = _parameters + .get("filter[tag]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_network_device_monitoring::ListDevicesOptionalParams::default(); params.page_number = page_number; - let response = match block_on(api.list_security_monitoring_rules_with_http_info(params)) { + params.page_size = page_size; + params.sort = sort; + params.filter_tag = filter_tag; + let response = match block_on(api.list_devices_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -20273,17 +20493,14 @@ fn test_v2_list_security_monitoring_rules( world.response.code = response.status.as_u16(); } -fn test_v2_create_security_monitoring_rule( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_get_device(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_network_device_monitoring .as_ref() .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_security_monitoring_rule_with_http_info(body)) { + let device_id = serde_json::from_value(_parameters.get("device_id").unwrap().clone()).unwrap(); + let response = match block_on(api.get_device_with_http_info(device_id)) { Ok(response) => response, Err(error) => { return match error { @@ -20301,19 +20518,14 @@ fn test_v2_create_security_monitoring_rule( world.response.code = response.status.as_u16(); } -fn test_v2_convert_security_monitoring_rule_from_json_to_terraform( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_get_interfaces(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_network_device_monitoring .as_ref() .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on( - api.convert_security_monitoring_rule_from_json_to_terraform_with_http_info(body), - ) { + let device_id = serde_json::from_value(_parameters.get("device_id").unwrap().clone()).unwrap(); + let response = match block_on(api.get_interfaces_with_http_info(device_id)) { Ok(response) => response, Err(error) => { return match error { @@ -20331,17 +20543,14 @@ fn test_v2_convert_security_monitoring_rule_from_json_to_terraform( world.response.code = response.status.as_u16(); } -fn test_v2_test_security_monitoring_rule( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_list_device_user_tags(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_network_device_monitoring .as_ref() .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.test_security_monitoring_rule_with_http_info(body)) { + let device_id = serde_json::from_value(_parameters.get("device_id").unwrap().clone()).unwrap(); + let response = match block_on(api.list_device_user_tags_with_http_info(device_id)) { Ok(response) => response, Err(error) => { return match error { @@ -20359,17 +20568,15 @@ fn test_v2_test_security_monitoring_rule( world.response.code = response.status.as_u16(); } -fn test_v2_validate_security_monitoring_rule( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_update_device_user_tags(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_network_device_monitoring .as_ref() .expect("api instance not found"); + let device_id = serde_json::from_value(_parameters.get("device_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.validate_security_monitoring_rule_with_http_info(body)) { + let response = match block_on(api.update_device_user_tags_with_http_info(device_id, body)) { Ok(response) => response, Err(error) => { return match error { @@ -20387,17 +20594,13 @@ fn test_v2_validate_security_monitoring_rule( world.response.code = response.status.as_u16(); } -fn test_v2_delete_security_monitoring_rule( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_list_org_configs(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_organizations .as_ref() .expect("api instance not found"); - let rule_id = serde_json::from_value(_parameters.get("rule_id").unwrap().clone()).unwrap(); - let response = match block_on(api.delete_security_monitoring_rule_with_http_info(rule_id)) { + let response = match block_on(api.list_org_configs_with_http_info()) { Ok(response) => response, Err(error) => { return match error { @@ -20415,17 +20618,15 @@ fn test_v2_delete_security_monitoring_rule( world.response.code = response.status.as_u16(); } -fn test_v2_get_security_monitoring_rule( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_get_org_config(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_organizations .as_ref() .expect("api instance not found"); - let rule_id = serde_json::from_value(_parameters.get("rule_id").unwrap().clone()).unwrap(); - let response = match block_on(api.get_security_monitoring_rule_with_http_info(rule_id)) { + let org_config_name = + serde_json::from_value(_parameters.get("org_config_name").unwrap().clone()).unwrap(); + let response = match block_on(api.get_org_config_with_http_info(org_config_name)) { Ok(response) => response, Err(error) => { return match error { @@ -20443,19 +20644,16 @@ fn test_v2_get_security_monitoring_rule( world.response.code = response.status.as_u16(); } -fn test_v2_update_security_monitoring_rule( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_update_org_config(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_organizations .as_ref() .expect("api instance not found"); - let rule_id = serde_json::from_value(_parameters.get("rule_id").unwrap().clone()).unwrap(); + let org_config_name = + serde_json::from_value(_parameters.get("org_config_name").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.update_security_monitoring_rule_with_http_info(rule_id, body)) - { + let response = match block_on(api.update_org_config_with_http_info(org_config_name, body)) { Ok(response) => response, Err(error) => { return match error { @@ -20473,101 +20671,23 @@ fn test_v2_update_security_monitoring_rule( world.response.code = response.status.as_u16(); } -fn test_v2_convert_existing_security_monitoring_rule( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { - let api = world - .api_instances - .v2_api_security_monitoring - .as_ref() - .expect("api instance not found"); - let rule_id = serde_json::from_value(_parameters.get("rule_id").unwrap().clone()).unwrap(); - let response = - match block_on(api.convert_existing_security_monitoring_rule_with_http_info(rule_id)) { - 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_v2_test_existing_security_monitoring_rule( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { - let api = world - .api_instances - .v2_api_security_monitoring - .as_ref() - .expect("api instance not found"); - let rule_id = serde_json::from_value(_parameters.get("rule_id").unwrap().clone()).unwrap(); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = - match block_on(api.test_existing_security_monitoring_rule_with_http_info(rule_id, body)) { - 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_v2_list_security_monitoring_signals( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_upload_idp_metadata(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_organizations .as_ref() .expect("api instance not found"); - let filter_query = _parameters - .get("filter[query]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_from = _parameters - .get("filter[from]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_to = _parameters - .get("filter[to]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let sort = _parameters - .get("sort") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_cursor = _parameters - .get("page[cursor]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_limit = _parameters - .get("page[limit]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = - datadogV2::api_security_monitoring::ListSecurityMonitoringSignalsOptionalParams::default(); - params.filter_query = filter_query; - params.filter_from = filter_from; - params.filter_to = filter_to; - params.sort = sort; - params.page_cursor = page_cursor; - params.page_limit = page_limit; - let response = match block_on(api.list_security_monitoring_signals_with_http_info(params)) { + let idp_file = _parameters.get("idp_file").and_then(|param| { + std::fs::read(format!( + "tests/scenarios/features/v{}/{}", + world.api_version, + param.as_str().unwrap() + )) + .ok() + }); + let mut params = datadogV2::api_organizations::UploadIdPMetadataOptionalParams::default(); + params.idp_file = idp_file; + let response = match block_on(api.upload_idp_metadata_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -20584,86 +20704,59 @@ fn test_v2_list_security_monitoring_signals( world.response.object = serde_json::to_value(response.entity).unwrap(); world.response.code = response.status.as_u16(); } -fn test_v2_list_security_monitoring_signals_with_pagination( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { + +fn test_v2_list_permissions(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_roles .as_ref() .expect("api instance not found"); - let filter_query = _parameters - .get("filter[query]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_from = _parameters - .get("filter[from]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_to = _parameters - .get("filter[to]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let sort = _parameters - .get("sort") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_cursor = _parameters - .get("page[cursor]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_limit = _parameters - .get("page[limit]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = - datadogV2::api_security_monitoring::ListSecurityMonitoringSignalsOptionalParams::default(); - params.filter_query = filter_query; - params.filter_from = filter_from; - params.filter_to = filter_to; - params.sort = sort; - params.page_cursor = page_cursor; - params.page_limit = page_limit; - let response = api.list_security_monitoring_signals_with_pagination(params); - let mut result = Vec::new(); - - block_on(async { - pin_mut!(response); - - while let Some(resp) = response.next().await { - match resp { - Ok(response) => { - result.push(response); - } - Err(error) => { - return match error { - Error::ResponseError(e) => { - if let Some(entity) = e.entity { - world.response.object = serde_json::to_value(entity).unwrap(); - } - } - _ => panic!("error parsing response: {}", error), - }; + let response = match block_on(api.list_permissions_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(); + } } - } + _ => panic!("error parsing response: {error}"), + }; } - }); - world.response.object = serde_json::to_value(result).unwrap(); - world.response.code = 200; + }; + world.response.object = serde_json::to_value(response.entity).unwrap(); + world.response.code = response.status.as_u16(); } -fn test_v2_search_security_monitoring_signals( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_list_roles(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_roles .as_ref() .expect("api instance not found"); - let body = _parameters - .get("body") + let page_size = _parameters + .get("page[size]") .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = - datadogV2::api_security_monitoring::SearchSecurityMonitoringSignalsOptionalParams::default( - ); - params.body = body; - let response = match block_on(api.search_security_monitoring_signals_with_http_info(params)) { + let page_number = _parameters + .get("page[number]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let sort = _parameters + .get("sort") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter = _parameters + .get("filter") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_id = _parameters + .get("filter[id]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_roles::ListRolesOptionalParams::default(); + params.page_size = page_size; + params.page_number = page_number; + params.sort = sort; + params.filter = filter; + params.filter_id = filter_id; + let response = match block_on(api.list_roles_with_http_info(params)) { Ok(response) => response, Err(error) => { return match error { @@ -20680,61 +20773,40 @@ fn test_v2_search_security_monitoring_signals( world.response.object = serde_json::to_value(response.entity).unwrap(); world.response.code = response.status.as_u16(); } -fn test_v2_search_security_monitoring_signals_with_pagination( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { + +fn test_v2_create_role(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_roles .as_ref() .expect("api instance not found"); - let body = _parameters - .get("body") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = - datadogV2::api_security_monitoring::SearchSecurityMonitoringSignalsOptionalParams::default( - ); - params.body = body; - let response = api.search_security_monitoring_signals_with_pagination(params); - let mut result = Vec::new(); - - block_on(async { - pin_mut!(response); - - while let Some(resp) = response.next().await { - match resp { - Ok(response) => { - result.push(response); - } - Err(error) => { - return match error { - Error::ResponseError(e) => { - if let Some(entity) = e.entity { - world.response.object = serde_json::to_value(entity).unwrap(); - } - } - _ => panic!("error parsing response: {}", error), - }; + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.create_role_with_http_info(body)) { + 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(result).unwrap(); - world.response.code = 200; + }; + world.response.object = serde_json::to_value(response.entity).unwrap(); + world.response.code = response.status.as_u16(); } -fn test_v2_get_security_monitoring_signal( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_delete_role(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_roles .as_ref() .expect("api instance not found"); - let signal_id = serde_json::from_value(_parameters.get("signal_id").unwrap().clone()).unwrap(); - let response = match block_on(api.get_security_monitoring_signal_with_http_info(signal_id)) { + let role_id = serde_json::from_value(_parameters.get("role_id").unwrap().clone()).unwrap(); + let response = match block_on(api.delete_role_with_http_info(role_id)) { Ok(response) => response, Err(error) => { return match error { @@ -20752,20 +20824,14 @@ fn test_v2_get_security_monitoring_signal( world.response.code = response.status.as_u16(); } -fn test_v2_edit_security_monitoring_signal_assignee( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_get_role(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_roles .as_ref() .expect("api instance not found"); - let signal_id = serde_json::from_value(_parameters.get("signal_id").unwrap().clone()).unwrap(); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on( - api.edit_security_monitoring_signal_assignee_with_http_info(signal_id, body), - ) { + let role_id = serde_json::from_value(_parameters.get("role_id").unwrap().clone()).unwrap(); + let response = match block_on(api.get_role_with_http_info(role_id)) { Ok(response) => response, Err(error) => { return match error { @@ -20783,20 +20849,15 @@ fn test_v2_edit_security_monitoring_signal_assignee( world.response.code = response.status.as_u16(); } -fn test_v2_edit_security_monitoring_signal_incidents( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_update_role(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_roles .as_ref() .expect("api instance not found"); - let signal_id = serde_json::from_value(_parameters.get("signal_id").unwrap().clone()).unwrap(); + let role_id = serde_json::from_value(_parameters.get("role_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on( - api.edit_security_monitoring_signal_incidents_with_http_info(signal_id, body), - ) { + let response = match block_on(api.update_role_with_http_info(role_id, body)) { Ok(response) => response, Err(error) => { return match error { @@ -20814,61 +20875,44 @@ fn test_v2_edit_security_monitoring_signal_incidents( world.response.code = response.status.as_u16(); } -fn test_v2_edit_security_monitoring_signal_state( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { +fn test_v2_clone_role(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_roles .as_ref() .expect("api instance not found"); - let signal_id = serde_json::from_value(_parameters.get("signal_id").unwrap().clone()).unwrap(); + let role_id = serde_json::from_value(_parameters.get("role_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = - match block_on(api.edit_security_monitoring_signal_state_with_http_info(signal_id, body)) { - 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 response = match block_on(api.clone_role_with_http_info(role_id, body)) { + 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(); } -fn test_v2_list_historical_jobs(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_remove_permission_from_role( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_roles .as_ref() .expect("api instance not found"); - let page_size = _parameters - .get("page[size]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_number = _parameters - .get("page[number]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let sort = _parameters - .get("sort") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_query = _parameters - .get("filter[query]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = - datadogV2::api_security_monitoring::ListHistoricalJobsOptionalParams::default(); - params.page_size = page_size; - params.page_number = page_number; - params.sort = sort; - params.filter_query = filter_query; - let response = match block_on(api.list_historical_jobs_with_http_info(params)) { + let role_id = serde_json::from_value(_parameters.get("role_id").unwrap().clone()).unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.remove_permission_from_role_with_http_info(role_id, body)) { Ok(response) => response, Err(error) => { return match error { @@ -20886,14 +20930,14 @@ fn test_v2_list_historical_jobs(world: &mut DatadogWorld, _parameters: &HashMap< world.response.code = response.status.as_u16(); } -fn test_v2_run_historical_job(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_role_permissions(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_roles .as_ref() .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.run_historical_job_with_http_info(body)) { + let role_id = serde_json::from_value(_parameters.get("role_id").unwrap().clone()).unwrap(); + let response = match block_on(api.list_role_permissions_with_http_info(role_id)) { Ok(response) => response, Err(error) => { return match error { @@ -20911,17 +20955,15 @@ fn test_v2_run_historical_job(world: &mut DatadogWorld, _parameters: &HashMap, -) { +fn test_v2_add_permission_to_role(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_roles .as_ref() .expect("api instance not found"); + let role_id = serde_json::from_value(_parameters.get("role_id").unwrap().clone()).unwrap(); let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.convert_job_result_to_signal_with_http_info(body)) { + let response = match block_on(api.add_permission_to_role_with_http_info(role_id, body)) { Ok(response) => response, Err(error) => { return match error { @@ -20939,14 +20981,15 @@ fn test_v2_convert_job_result_to_signal( world.response.code = response.status.as_u16(); } -fn test_v2_delete_historical_job(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_remove_user_from_role(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_roles .as_ref() .expect("api instance not found"); - let job_id = serde_json::from_value(_parameters.get("job_id").unwrap().clone()).unwrap(); - let response = match block_on(api.delete_historical_job_with_http_info(job_id)) { + let role_id = serde_json::from_value(_parameters.get("role_id").unwrap().clone()).unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.remove_user_from_role_with_http_info(role_id, body)) { Ok(response) => response, Err(error) => { return match error { @@ -20964,14 +21007,31 @@ fn test_v2_delete_historical_job(world: &mut DatadogWorld, _parameters: &HashMap world.response.code = response.status.as_u16(); } -fn test_v2_get_historical_job(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_list_role_users(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_roles .as_ref() .expect("api instance not found"); - let job_id = serde_json::from_value(_parameters.get("job_id").unwrap().clone()).unwrap(); - let response = match block_on(api.get_historical_job_with_http_info(job_id)) { + let role_id = serde_json::from_value(_parameters.get("role_id").unwrap().clone()).unwrap(); + let page_size = _parameters + .get("page[size]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_number = _parameters + .get("page[number]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let sort = _parameters + .get("sort") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter = _parameters + .get("filter") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_roles::ListRoleUsersOptionalParams::default(); + params.page_size = page_size; + params.page_number = page_number; + params.sort = sort; + params.filter = filter; + let response = match block_on(api.list_role_users_with_http_info(role_id, params)) { Ok(response) => response, Err(error) => { return match error { @@ -20989,14 +21049,15 @@ fn test_v2_get_historical_job(world: &mut DatadogWorld, _parameters: &HashMap) { +fn test_v2_add_user_to_role(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances - .v2_api_security_monitoring + .v2_api_roles .as_ref() .expect("api instance not found"); - let job_id = serde_json::from_value(_parameters.get("job_id").unwrap().clone()).unwrap(); - let response = match block_on(api.cancel_historical_job_with_http_info(job_id)) { + let role_id = serde_json::from_value(_parameters.get("role_id").unwrap().clone()).unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.add_user_to_role_with_http_info(role_id, body)) { Ok(response) => response, Err(error) => { return match error {