From b8807c64e6b812e6b7653b47b50ccf0fd8b311b7 Mon Sep 17 00:00:00 2001 From: "ci.datadog-api-spec" Date: Mon, 27 Oct 2025 20:35:36 +0000 Subject: [PATCH] Regenerate client from commit 3711875 of spec repo --- .generator/schemas/v2/openapi.yaml | 362 +++++++++++++ LICENSE-3rdparty.csv | 1 - .../v2_security-monitoring_GetSecretsRules.rs | 16 + ...ecurity-monitoring_ListMultipleRulesets.rs | 26 + src/datadog/configuration.rs | 2 + src/datadogV2/api/api_security_monitoring.rs | 288 ++++++++++ src/datadogV2/model/mod.rs | 46 ++ .../model_get_multiple_rulesets_request.rs | 104 ++++ ...odel_get_multiple_rulesets_request_data.rs | 139 +++++ ...ltiple_rulesets_request_data_attributes.rs | 137 +++++ ...get_multiple_rulesets_request_data_type.rs | 48 ++ .../model_get_multiple_rulesets_response.rs | 104 ++++ ...del_get_multiple_rulesets_response_data.rs | 140 +++++ ...tiple_rulesets_response_data_attributes.rs | 108 ++++ ...response_data_attributes_rulesets_items.rs | 161 ++++++ ...nse_data_attributes_rulesets_items_data.rs | 119 +++++ ...ata_attributes_rulesets_items_data_type.rs | 48 ++ ...a_attributes_rulesets_items_rules_items.rs | 493 ++++++++++++++++++ ...esets_items_rules_items_arguments_items.rs | 120 +++++ ...ributes_rulesets_items_rules_items_data.rs | 124 +++++ ...es_rulesets_items_rules_items_data_type.rs | 50 ++ ..._rulesets_items_rules_items_tests_items.rs | 143 +++++ ...et_multiple_rulesets_response_data_type.rs | 48 ++ .../model/model_secret_rule_array.rs | 90 ++++ src/datadogV2/model/model_secret_rule_data.rs | 134 +++++ .../model_secret_rule_data_attributes.rs | 239 +++++++++ ...t_rule_data_attributes_match_validation.rs | 226 ++++++++ ...lidation_invalid_http_status_code_items.rs | 121 +++++ ...validation_valid_http_status_code_items.rs | 120 +++++ .../model/model_secret_rule_data_type.rs | 48 ++ .../features/v2/security_monitoring.feature | 19 +- tests/scenarios/features/v2/undo.json | 14 + tests/scenarios/function_mappings.rs | 56 ++ 33 files changed, 3891 insertions(+), 3 deletions(-) create mode 100644 examples/v2_security-monitoring_GetSecretsRules.rs create mode 100644 examples/v2_security-monitoring_ListMultipleRulesets.rs create mode 100644 src/datadogV2/model/model_get_multiple_rulesets_request.rs create mode 100644 src/datadogV2/model/model_get_multiple_rulesets_request_data.rs create mode 100644 src/datadogV2/model/model_get_multiple_rulesets_request_data_attributes.rs create mode 100644 src/datadogV2/model/model_get_multiple_rulesets_request_data_type.rs create mode 100644 src/datadogV2/model/model_get_multiple_rulesets_response.rs create mode 100644 src/datadogV2/model/model_get_multiple_rulesets_response_data.rs create mode 100644 src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes.rs create mode 100644 src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items.rs create mode 100644 src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_data.rs create mode 100644 src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_data_type.rs create mode 100644 src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items.rs create mode 100644 src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items_arguments_items.rs create mode 100644 src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items_data.rs create mode 100644 src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items_data_type.rs create mode 100644 src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items_tests_items.rs create mode 100644 src/datadogV2/model/model_get_multiple_rulesets_response_data_type.rs create mode 100644 src/datadogV2/model/model_secret_rule_array.rs create mode 100644 src/datadogV2/model/model_secret_rule_data.rs create mode 100644 src/datadogV2/model/model_secret_rule_data_attributes.rs create mode 100644 src/datadogV2/model/model_secret_rule_data_attributes_match_validation.rs create mode 100644 src/datadogV2/model/model_secret_rule_data_attributes_match_validation_invalid_http_status_code_items.rs create mode 100644 src/datadogV2/model/model_secret_rule_data_attributes_match_validation_valid_http_status_code_items.rs create mode 100644 src/datadogV2/model/model_secret_rule_data_type.rs diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index 76247abea..2f29c0ae8 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -21612,6 +21612,207 @@ components: - ASSIGNEE - CASE - TEAM_OWNERS + GetMultipleRulesetsRequest: + properties: + data: + $ref: '#/components/schemas/GetMultipleRulesetsRequestData' + type: object + GetMultipleRulesetsRequestData: + properties: + attributes: + $ref: '#/components/schemas/GetMultipleRulesetsRequestDataAttributes' + id: + type: string + type: + $ref: '#/components/schemas/GetMultipleRulesetsRequestDataType' + required: + - type + type: object + GetMultipleRulesetsRequestDataAttributes: + properties: + include_testing_rules: + type: boolean + include_tests: + type: boolean + rulesets: + items: + type: string + type: array + type: object + GetMultipleRulesetsRequestDataType: + default: get_multiple_rulesets_request + description: Get multiple rulesets request resource type. + enum: + - get_multiple_rulesets_request + example: get_multiple_rulesets_request + type: string + x-enum-varnames: + - GET_MULTIPLE_RULESETS_REQUEST + GetMultipleRulesetsResponse: + properties: + data: + $ref: '#/components/schemas/GetMultipleRulesetsResponseData' + type: object + GetMultipleRulesetsResponseData: + properties: + attributes: + $ref: '#/components/schemas/GetMultipleRulesetsResponseDataAttributes' + id: + type: string + type: + $ref: '#/components/schemas/GetMultipleRulesetsResponseDataType' + required: + - type + type: object + GetMultipleRulesetsResponseDataAttributes: + properties: + rulesets: + items: + $ref: '#/components/schemas/GetMultipleRulesetsResponseDataAttributesRulesetsItems' + type: array + type: object + GetMultipleRulesetsResponseDataAttributesRulesetsItems: + properties: + data: + $ref: '#/components/schemas/GetMultipleRulesetsResponseDataAttributesRulesetsItemsData' + description: + type: string + name: + type: string + rules: + items: + $ref: '#/components/schemas/GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItems' + type: array + short_description: + type: string + required: + - data + type: object + GetMultipleRulesetsResponseDataAttributesRulesetsItemsData: + properties: + id: + type: string + type: + $ref: '#/components/schemas/GetMultipleRulesetsResponseDataAttributesRulesetsItemsDataType' + required: + - type + type: object + GetMultipleRulesetsResponseDataAttributesRulesetsItemsDataType: + default: rulesets + description: Rulesets resource type. + enum: + - rulesets + example: rulesets + type: string + x-enum-varnames: + - RULESETS + GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItems: + properties: + arguments: + items: + $ref: '#/components/schemas/GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsArgumentsItems' + type: array + category: + type: string + checksum: + type: string + code: + type: string + created_at: + format: date-time + type: string + created_by: + type: string + cve: + type: string + cwe: + type: string + data: + $ref: '#/components/schemas/GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsData' + description: + type: string + documentation_url: + type: string + entity_checked: + type: string + is_published: + type: boolean + is_testing: + type: boolean + language: + type: string + last_updated_at: + format: date-time + type: string + last_updated_by: + type: string + name: + type: string + regex: + type: string + severity: + type: string + short_description: + type: string + should_use_ai_fix: + type: boolean + tests: + items: + $ref: '#/components/schemas/GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsTestsItems' + type: array + tree_sitter_query: + type: string + type: + type: string + required: + - data + type: object + GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsArgumentsItems: + properties: + description: + type: string + name: + type: string + type: object + GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsData: + properties: + id: + type: string + type: + $ref: '#/components/schemas/GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsDataType' + required: + - type + type: object + GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsDataType: + default: rules + description: Rules resource type. + enum: + - rules + example: rules + type: string + x-enum-varnames: + - RULES + GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsTestsItems: + properties: + annotation_count: + format: int64 + maximum: 65535 + minimum: 0 + type: integer + code: + type: string + filename: + type: string + type: object + GetMultipleRulesetsResponseDataType: + default: get_multiple_rulesets_response + description: Get multiple rulesets response resource type. + enum: + - get_multiple_rulesets_response + example: get_multiple_rulesets_response + type: string + x-enum-varnames: + - GET_MULTIPLE_RULESETS_RESPONSE GetResourceEvaluationFiltersResponse: description: The definition of `GetResourceEvaluationFiltersResponse` object. properties: @@ -42844,6 +43045,116 @@ components: - ISSUE_ASSIGNEE - ISSUE_CASE - ISSUE_TEAM_OWNERS + SecretRuleArray: + properties: + data: + items: + $ref: '#/components/schemas/SecretRuleData' + type: array + required: + - data + type: object + SecretRuleData: + properties: + attributes: + $ref: '#/components/schemas/SecretRuleDataAttributes' + id: + type: string + type: + $ref: '#/components/schemas/SecretRuleDataType' + required: + - type + type: object + SecretRuleDataAttributes: + properties: + default_included_keywords: + items: + type: string + type: array + description: + type: string + license: + type: string + match_validation: + $ref: '#/components/schemas/SecretRuleDataAttributesMatchValidation' + name: + type: string + pattern: + type: string + priority: + type: string + sds_id: + type: string + validators: + items: + type: string + type: array + type: object + SecretRuleDataAttributesMatchValidation: + properties: + endpoint: + type: string + hosts: + items: + type: string + type: array + http_method: + type: string + invalid_http_status_code: + items: + $ref: '#/components/schemas/SecretRuleDataAttributesMatchValidationInvalidHttpStatusCodeItems' + type: array + request_headers: + additionalProperties: + type: string + type: object + timeout_seconds: + format: int64 + maximum: 1.8446744073709552e+19 + minimum: 0 + type: integer + type: + type: string + valid_http_status_code: + items: + $ref: '#/components/schemas/SecretRuleDataAttributesMatchValidationValidHttpStatusCodeItems' + type: array + type: object + SecretRuleDataAttributesMatchValidationInvalidHttpStatusCodeItems: + properties: + end: + format: int64 + maximum: 1.8446744073709552e+19 + minimum: 0 + type: integer + start: + format: int64 + maximum: 1.8446744073709552e+19 + minimum: 0 + type: integer + type: object + SecretRuleDataAttributesMatchValidationValidHttpStatusCodeItems: + properties: + end: + format: int64 + maximum: 1.8446744073709552e+19 + minimum: 0 + type: integer + start: + format: int64 + maximum: 1.8446744073709552e+19 + minimum: 0 + type: integer + type: object + SecretRuleDataType: + default: secret_rule + description: Secret rule resource type. + enum: + - secret_rule + example: secret_rule + type: string + x-enum-varnames: + - SECRET_RULE SecurityFilter: description: The security filter's properties. properties: @@ -77328,6 +77639,57 @@ paths: tags: - Static Analysis x-unstable: '**Note**: This endpoint may be subject to changes.' + /api/v2/static-analysis/rulesets: + post: + description: Get rules for multiple rulesets in batch. + operationId: ListMultipleRulesets + requestBody: + content: + application/json: + schema: + $ref: '#/components/schemas/GetMultipleRulesetsRequest' + required: true + responses: + '200': + content: + application/json: + schema: + $ref: '#/components/schemas/GetMultipleRulesetsResponse' + description: OK + '429': + $ref: '#/components/responses/TooManyRequestsResponse' + security: + - apiKeyAuth: [] + appKeyAuth: [] + - AuthZ: + - code_analysis_read + summary: Ruleset get multiple + tags: + - Security Monitoring + x-unstable: '**Note**: This endpoint may be subject to changes.' + /api/v2/static-analysis/secrets/rules: + get: + description: Returns list of Secrets rules with ID, Pattern, Description, Priority, + and SDS ID + operationId: GetSecretsRules + responses: + '200': + content: + application/json: + schema: + $ref: '#/components/schemas/SecretRuleArray' + description: OK + '429': + $ref: '#/components/responses/TooManyRequestsResponse' + security: + - apiKeyAuth: [] + appKeyAuth: [] + - AuthZ: + - code_analysis_read + summary: Returns list of Secrets rules + tags: + - Security Monitoring + x-unstable: '**Note**: This endpoint may be subject to changes.' /api/v2/synthetics/settings/on_demand_concurrency_cap: get: description: Get the on-demand concurrency cap. diff --git a/LICENSE-3rdparty.csv b/LICENSE-3rdparty.csv index 94e543c7e..2468006c5 100644 --- a/LICENSE-3rdparty.csv +++ b/LICENSE-3rdparty.csv @@ -161,7 +161,6 @@ want,https://github.com/seanmonstar/want,MIT,Sean McArthur Result> + { + match self.get_secrets_rules_with_http_info().await { + Ok(response_content) => { + if let Some(e) = response_content.entity { + Ok(e) + } else { + Err(datadog::Error::Serde(serde::de::Error::custom( + "response content was None", + ))) + } + } + Err(err) => Err(err), + } + } + + /// Returns list of Secrets rules with ID, Pattern, Description, Priority, and SDS ID + pub async fn get_secrets_rules_with_http_info( + &self, + ) -> Result< + datadog::ResponseContent, + datadog::Error, + > { + let local_configuration = &self.config; + let operation_id = "v2.get_secrets_rules"; + if local_configuration.is_unstable_operation_enabled(operation_id) { + warn!("Using unstable operation {operation_id}"); + } else { + let local_error = datadog::UnstableOperationDisabledError { + msg: "Operation 'v2.get_secrets_rules' is not enabled".to_string(), + }; + return Err(datadog::Error::UnstableOperationDisabledError(local_error)); + } + + let local_client = &self.client; + + let local_uri_str = format!( + "{}/api/v2/static-analysis/secrets/rules", + local_configuration.get_operation_host(operation_id) + ); + let mut local_req_builder = + local_client.request(reqwest::Method::GET, local_uri_str.as_str()); + + // build headers + let mut headers = HeaderMap::new(); + headers.insert("Accept", HeaderValue::from_static("application/json")); + + // build user agent + match HeaderValue::from_str(local_configuration.user_agent.as_str()) { + Ok(user_agent) => headers.insert(reqwest::header::USER_AGENT, user_agent), + Err(e) => { + log::warn!("Failed to parse user agent header: {e}, falling back to default"); + headers.insert( + reqwest::header::USER_AGENT, + HeaderValue::from_static(datadog::DEFAULT_USER_AGENT.as_str()), + ) + } + }; + + // build auth + if let Some(local_key) = local_configuration.auth_keys.get("apiKeyAuth") { + headers.insert( + "DD-API-KEY", + HeaderValue::from_str(local_key.key.as_str()) + .expect("failed to parse DD-API-KEY header"), + ); + }; + if let Some(local_key) = local_configuration.auth_keys.get("appKeyAuth") { + headers.insert( + "DD-APPLICATION-KEY", + HeaderValue::from_str(local_key.key.as_str()) + .expect("failed to parse DD-APPLICATION-KEY header"), + ); + }; + + local_req_builder = local_req_builder.headers(headers); + let local_req = local_req_builder.build()?; + log::debug!("request content: {:?}", local_req.body()); + let local_resp = local_client.execute(local_req).await?; + + let local_status = local_resp.status(); + let local_content = local_resp.text().await?; + log::debug!("response content: {}", local_content); + + if !local_status.is_client_error() && !local_status.is_server_error() { + match serde_json::from_str::(&local_content) { + Ok(e) => { + return Ok(datadog::ResponseContent { + status: local_status, + content: local_content, + entity: Some(e), + }) + } + Err(e) => return Err(datadog::Error::Serde(e)), + }; + } else { + let local_entity: Option = + serde_json::from_str(&local_content).ok(); + let local_error = datadog::ResponseContent { + status: local_status, + content: local_content, + entity: local_entity, + }; + Err(datadog::Error::ResponseError(local_error)) + } + } + /// Get the details of a specific security filter. /// /// See the [security filter guide]() @@ -6944,6 +7070,168 @@ impl SecurityMonitoringAPI { } } + /// Get rules for multiple rulesets in batch. + pub async fn list_multiple_rulesets( + &self, + body: crate::datadogV2::model::GetMultipleRulesetsRequest, + ) -> Result< + crate::datadogV2::model::GetMultipleRulesetsResponse, + datadog::Error, + > { + match self.list_multiple_rulesets_with_http_info(body).await { + Ok(response_content) => { + if let Some(e) = response_content.entity { + Ok(e) + } else { + Err(datadog::Error::Serde(serde::de::Error::custom( + "response content was None", + ))) + } + } + Err(err) => Err(err), + } + } + + /// Get rules for multiple rulesets in batch. + pub async fn list_multiple_rulesets_with_http_info( + &self, + body: crate::datadogV2::model::GetMultipleRulesetsRequest, + ) -> Result< + datadog::ResponseContent, + datadog::Error, + > { + let local_configuration = &self.config; + let operation_id = "v2.list_multiple_rulesets"; + if local_configuration.is_unstable_operation_enabled(operation_id) { + warn!("Using unstable operation {operation_id}"); + } else { + let local_error = datadog::UnstableOperationDisabledError { + msg: "Operation 'v2.list_multiple_rulesets' is not enabled".to_string(), + }; + return Err(datadog::Error::UnstableOperationDisabledError(local_error)); + } + + let local_client = &self.client; + + let local_uri_str = format!( + "{}/api/v2/static-analysis/rulesets", + 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("application/json")); + + // build user agent + match HeaderValue::from_str(local_configuration.user_agent.as_str()) { + Ok(user_agent) => headers.insert(reqwest::header::USER_AGENT, user_agent), + Err(e) => { + log::warn!("Failed to parse user agent header: {e}, falling back to default"); + headers.insert( + reqwest::header::USER_AGENT, + HeaderValue::from_static(datadog::DEFAULT_USER_AGENT.as_str()), + ) + } + }; + + // build auth + if let Some(local_key) = local_configuration.auth_keys.get("apiKeyAuth") { + headers.insert( + "DD-API-KEY", + HeaderValue::from_str(local_key.key.as_str()) + .expect("failed to parse DD-API-KEY header"), + ); + }; + if let Some(local_key) = local_configuration.auth_keys.get("appKeyAuth") { + headers.insert( + "DD-APPLICATION-KEY", + HeaderValue::from_str(local_key.key.as_str()) + .expect("failed to parse DD-APPLICATION-KEY header"), + ); + }; + + // build body parameters + let output = Vec::new(); + let mut ser = serde_json::Serializer::with_formatter(output, datadog::DDFormatter); + if body.serialize(&mut ser).is_ok() { + if let Some(content_encoding) = headers.get("Content-Encoding") { + match content_encoding.to_str().unwrap_or_default() { + "gzip" => { + let mut enc = GzEncoder::new(Vec::new(), Compression::default()); + let _ = enc.write_all(ser.into_inner().as_slice()); + match enc.finish() { + Ok(buf) => { + local_req_builder = local_req_builder.body(buf); + } + Err(e) => return Err(datadog::Error::Io(e)), + } + } + "deflate" => { + let mut enc = ZlibEncoder::new(Vec::new(), Compression::default()); + let _ = enc.write_all(ser.into_inner().as_slice()); + match enc.finish() { + Ok(buf) => { + local_req_builder = local_req_builder.body(buf); + } + Err(e) => return Err(datadog::Error::Io(e)), + } + } + "zstd1" => { + let mut enc = zstd::stream::Encoder::new(Vec::new(), 0).unwrap(); + let _ = enc.write_all(ser.into_inner().as_slice()); + match enc.finish() { + Ok(buf) => { + local_req_builder = local_req_builder.body(buf); + } + Err(e) => return Err(datadog::Error::Io(e)), + } + } + _ => { + local_req_builder = local_req_builder.body(ser.into_inner()); + } + } + } else { + local_req_builder = local_req_builder.body(ser.into_inner()); + } + } + + local_req_builder = local_req_builder.headers(headers); + let local_req = local_req_builder.build()?; + log::debug!("request content: {:?}", local_req.body()); + let local_resp = local_client.execute(local_req).await?; + + let local_status = local_resp.status(); + let local_content = local_resp.text().await?; + log::debug!("response content: {}", local_content); + + if !local_status.is_client_error() && !local_status.is_server_error() { + match serde_json::from_str::( + &local_content, + ) { + Ok(e) => { + return Ok(datadog::ResponseContent { + status: local_status, + content: local_content, + entity: Some(e), + }) + } + Err(e) => return Err(datadog::Error::Serde(e)), + }; + } else { + let local_entity: Option = + serde_json::from_str(&local_content).ok(); + let local_error = datadog::ResponseContent { + status: local_status, + content: local_content, + entity: local_entity, + }; + Err(datadog::Error::ResponseError(local_error)) + } + } + /// Get a list of security scanned assets metadata for an organization. /// /// ### Pagination diff --git a/src/datadogV2/model/mod.rs b/src/datadogV2/model/mod.rs index 4c01be1ab..1118b290a 100644 --- a/src/datadogV2/model/mod.rs +++ b/src/datadogV2/model/mod.rs @@ -6172,6 +6172,52 @@ pub mod model_resolve_vulnerable_symbols_response_results_vulnerable_symbols_sym pub use self::model_resolve_vulnerable_symbols_response_results_vulnerable_symbols_symbols::ResolveVulnerableSymbolsResponseResultsVulnerableSymbolsSymbols; pub mod model_resolve_vulnerable_symbols_response_data_type; pub use self::model_resolve_vulnerable_symbols_response_data_type::ResolveVulnerableSymbolsResponseDataType; +pub mod model_get_multiple_rulesets_request; +pub use self::model_get_multiple_rulesets_request::GetMultipleRulesetsRequest; +pub mod model_get_multiple_rulesets_request_data; +pub use self::model_get_multiple_rulesets_request_data::GetMultipleRulesetsRequestData; +pub mod model_get_multiple_rulesets_request_data_attributes; +pub use self::model_get_multiple_rulesets_request_data_attributes::GetMultipleRulesetsRequestDataAttributes; +pub mod model_get_multiple_rulesets_request_data_type; +pub use self::model_get_multiple_rulesets_request_data_type::GetMultipleRulesetsRequestDataType; +pub mod model_get_multiple_rulesets_response; +pub use self::model_get_multiple_rulesets_response::GetMultipleRulesetsResponse; +pub mod model_get_multiple_rulesets_response_data; +pub use self::model_get_multiple_rulesets_response_data::GetMultipleRulesetsResponseData; +pub mod model_get_multiple_rulesets_response_data_attributes; +pub use self::model_get_multiple_rulesets_response_data_attributes::GetMultipleRulesetsResponseDataAttributes; +pub mod model_get_multiple_rulesets_response_data_attributes_rulesets_items; +pub use self::model_get_multiple_rulesets_response_data_attributes_rulesets_items::GetMultipleRulesetsResponseDataAttributesRulesetsItems; +pub mod model_get_multiple_rulesets_response_data_attributes_rulesets_items_data; +pub use self::model_get_multiple_rulesets_response_data_attributes_rulesets_items_data::GetMultipleRulesetsResponseDataAttributesRulesetsItemsData; +pub mod model_get_multiple_rulesets_response_data_attributes_rulesets_items_data_type; +pub use self::model_get_multiple_rulesets_response_data_attributes_rulesets_items_data_type::GetMultipleRulesetsResponseDataAttributesRulesetsItemsDataType; +pub mod model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items; +pub use self::model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items::GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItems; +pub mod model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items_arguments_items; +pub use self::model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items_arguments_items::GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsArgumentsItems; +pub mod model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items_data; +pub use self::model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items_data::GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsData; +pub mod model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items_data_type; +pub use self::model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items_data_type::GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsDataType; +pub mod model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items_tests_items; +pub use self::model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items_tests_items::GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsTestsItems; +pub mod model_get_multiple_rulesets_response_data_type; +pub use self::model_get_multiple_rulesets_response_data_type::GetMultipleRulesetsResponseDataType; +pub mod model_secret_rule_array; +pub use self::model_secret_rule_array::SecretRuleArray; +pub mod model_secret_rule_data; +pub use self::model_secret_rule_data::SecretRuleData; +pub mod model_secret_rule_data_attributes; +pub use self::model_secret_rule_data_attributes::SecretRuleDataAttributes; +pub mod model_secret_rule_data_attributes_match_validation; +pub use self::model_secret_rule_data_attributes_match_validation::SecretRuleDataAttributesMatchValidation; +pub mod model_secret_rule_data_attributes_match_validation_invalid_http_status_code_items; +pub use self::model_secret_rule_data_attributes_match_validation_invalid_http_status_code_items::SecretRuleDataAttributesMatchValidationInvalidHttpStatusCodeItems; +pub mod model_secret_rule_data_attributes_match_validation_valid_http_status_code_items; +pub use self::model_secret_rule_data_attributes_match_validation_valid_http_status_code_items::SecretRuleDataAttributesMatchValidationValidHttpStatusCodeItems; +pub mod model_secret_rule_data_type; +pub use self::model_secret_rule_data_type::SecretRuleDataType; pub mod model_on_demand_concurrency_cap_response; pub use self::model_on_demand_concurrency_cap_response::OnDemandConcurrencyCapResponse; pub mod model_on_demand_concurrency_cap; diff --git a/src/datadogV2/model/model_get_multiple_rulesets_request.rs b/src/datadogV2/model/model_get_multiple_rulesets_request.rs new file mode 100644 index 000000000..baee53685 --- /dev/null +++ b/src/datadogV2/model/model_get_multiple_rulesets_request.rs @@ -0,0 +1,104 @@ +// 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}; + +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct GetMultipleRulesetsRequest { + #[serde(rename = "data")] + pub data: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl GetMultipleRulesetsRequest { + pub fn new() -> GetMultipleRulesetsRequest { + GetMultipleRulesetsRequest { + data: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn data(mut self, value: crate::datadogV2::model::GetMultipleRulesetsRequestData) -> Self { + self.data = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for GetMultipleRulesetsRequest { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for GetMultipleRulesetsRequest { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct GetMultipleRulesetsRequestVisitor; + impl<'a> Visitor<'a> for GetMultipleRulesetsRequestVisitor { + type Value = GetMultipleRulesetsRequest; + + 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 data: 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() { + "data" => { + if v.is_null() { + continue; + } + data = 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 content = GetMultipleRulesetsRequest { + data, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(GetMultipleRulesetsRequestVisitor) + } +} diff --git a/src/datadogV2/model/model_get_multiple_rulesets_request_data.rs b/src/datadogV2/model/model_get_multiple_rulesets_request_data.rs new file mode 100644 index 000000000..b83039a55 --- /dev/null +++ b/src/datadogV2/model/model_get_multiple_rulesets_request_data.rs @@ -0,0 +1,139 @@ +// 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}; + +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct GetMultipleRulesetsRequestData { + #[serde(rename = "attributes")] + pub attributes: Option, + #[serde(rename = "id")] + pub id: Option, + /// Get multiple rulesets request resource type. + #[serde(rename = "type")] + pub type_: crate::datadogV2::model::GetMultipleRulesetsRequestDataType, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl GetMultipleRulesetsRequestData { + pub fn new( + type_: crate::datadogV2::model::GetMultipleRulesetsRequestDataType, + ) -> GetMultipleRulesetsRequestData { + GetMultipleRulesetsRequestData { + attributes: None, + id: None, + type_, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn attributes( + mut self, + value: crate::datadogV2::model::GetMultipleRulesetsRequestDataAttributes, + ) -> Self { + self.attributes = Some(value); + self + } + + pub fn id(mut self, value: String) -> Self { + self.id = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for GetMultipleRulesetsRequestData { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct GetMultipleRulesetsRequestDataVisitor; + impl<'a> Visitor<'a> for GetMultipleRulesetsRequestDataVisitor { + type Value = GetMultipleRulesetsRequestData; + + 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 attributes: Option< + crate::datadogV2::model::GetMultipleRulesetsRequestDataAttributes, + > = None; + let mut id: Option = None; + let mut type_: 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() { + "attributes" => { + if v.is_null() { + continue; + } + attributes = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "id" => { + if v.is_null() { + continue; + } + id = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "type" => { + type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _type_) = type_ { + match _type_ { + crate::datadogV2::model::GetMultipleRulesetsRequestDataType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?; + + let content = GetMultipleRulesetsRequestData { + attributes, + id, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(GetMultipleRulesetsRequestDataVisitor) + } +} diff --git a/src/datadogV2/model/model_get_multiple_rulesets_request_data_attributes.rs b/src/datadogV2/model/model_get_multiple_rulesets_request_data_attributes.rs new file mode 100644 index 000000000..dda9bf7eb --- /dev/null +++ b/src/datadogV2/model/model_get_multiple_rulesets_request_data_attributes.rs @@ -0,0 +1,137 @@ +// 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}; + +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct GetMultipleRulesetsRequestDataAttributes { + #[serde(rename = "include_testing_rules")] + pub include_testing_rules: Option, + #[serde(rename = "include_tests")] + pub include_tests: Option, + #[serde(rename = "rulesets")] + pub rulesets: Option>, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl GetMultipleRulesetsRequestDataAttributes { + pub fn new() -> GetMultipleRulesetsRequestDataAttributes { + GetMultipleRulesetsRequestDataAttributes { + include_testing_rules: None, + include_tests: None, + rulesets: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn include_testing_rules(mut self, value: bool) -> Self { + self.include_testing_rules = Some(value); + self + } + + pub fn include_tests(mut self, value: bool) -> Self { + self.include_tests = Some(value); + self + } + + pub fn rulesets(mut self, value: Vec) -> Self { + self.rulesets = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for GetMultipleRulesetsRequestDataAttributes { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for GetMultipleRulesetsRequestDataAttributes { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct GetMultipleRulesetsRequestDataAttributesVisitor; + impl<'a> Visitor<'a> for GetMultipleRulesetsRequestDataAttributesVisitor { + type Value = GetMultipleRulesetsRequestDataAttributes; + + 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 include_testing_rules: Option = None; + let mut include_tests: Option = None; + let mut rulesets: 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() { + "include_testing_rules" => { + if v.is_null() { + continue; + } + include_testing_rules = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "include_tests" => { + if v.is_null() { + continue; + } + include_tests = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "rulesets" => { + if v.is_null() { + continue; + } + rulesets = 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 content = GetMultipleRulesetsRequestDataAttributes { + include_testing_rules, + include_tests, + rulesets, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(GetMultipleRulesetsRequestDataAttributesVisitor) + } +} diff --git a/src/datadogV2/model/model_get_multiple_rulesets_request_data_type.rs b/src/datadogV2/model/model_get_multiple_rulesets_request_data_type.rs new file mode 100644 index 000000000..89d4ba2c0 --- /dev/null +++ b/src/datadogV2/model/model_get_multiple_rulesets_request_data_type.rs @@ -0,0 +1,48 @@ +// 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::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum GetMultipleRulesetsRequestDataType { + GET_MULTIPLE_RULESETS_REQUEST, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for GetMultipleRulesetsRequestDataType { + fn to_string(&self) -> String { + match self { + Self::GET_MULTIPLE_RULESETS_REQUEST => String::from("get_multiple_rulesets_request"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for GetMultipleRulesetsRequestDataType { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for GetMultipleRulesetsRequestDataType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "get_multiple_rulesets_request" => Self::GET_MULTIPLE_RULESETS_REQUEST, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_get_multiple_rulesets_response.rs b/src/datadogV2/model/model_get_multiple_rulesets_response.rs new file mode 100644 index 000000000..280ea1538 --- /dev/null +++ b/src/datadogV2/model/model_get_multiple_rulesets_response.rs @@ -0,0 +1,104 @@ +// 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}; + +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct GetMultipleRulesetsResponse { + #[serde(rename = "data")] + pub data: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl GetMultipleRulesetsResponse { + pub fn new() -> GetMultipleRulesetsResponse { + GetMultipleRulesetsResponse { + data: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn data(mut self, value: crate::datadogV2::model::GetMultipleRulesetsResponseData) -> Self { + self.data = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for GetMultipleRulesetsResponse { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for GetMultipleRulesetsResponse { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct GetMultipleRulesetsResponseVisitor; + impl<'a> Visitor<'a> for GetMultipleRulesetsResponseVisitor { + type Value = GetMultipleRulesetsResponse; + + 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 data: 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() { + "data" => { + if v.is_null() { + continue; + } + data = 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 content = GetMultipleRulesetsResponse { + data, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(GetMultipleRulesetsResponseVisitor) + } +} diff --git a/src/datadogV2/model/model_get_multiple_rulesets_response_data.rs b/src/datadogV2/model/model_get_multiple_rulesets_response_data.rs new file mode 100644 index 000000000..9fc6c26a8 --- /dev/null +++ b/src/datadogV2/model/model_get_multiple_rulesets_response_data.rs @@ -0,0 +1,140 @@ +// 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}; + +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct GetMultipleRulesetsResponseData { + #[serde(rename = "attributes")] + pub attributes: Option, + #[serde(rename = "id")] + pub id: Option, + /// Get multiple rulesets response resource type. + #[serde(rename = "type")] + pub type_: crate::datadogV2::model::GetMultipleRulesetsResponseDataType, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl GetMultipleRulesetsResponseData { + pub fn new( + type_: crate::datadogV2::model::GetMultipleRulesetsResponseDataType, + ) -> GetMultipleRulesetsResponseData { + GetMultipleRulesetsResponseData { + attributes: None, + id: None, + type_, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn attributes( + mut self, + value: crate::datadogV2::model::GetMultipleRulesetsResponseDataAttributes, + ) -> Self { + self.attributes = Some(value); + self + } + + pub fn id(mut self, value: String) -> Self { + self.id = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for GetMultipleRulesetsResponseData { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct GetMultipleRulesetsResponseDataVisitor; + impl<'a> Visitor<'a> for GetMultipleRulesetsResponseDataVisitor { + type Value = GetMultipleRulesetsResponseData; + + 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 attributes: Option< + crate::datadogV2::model::GetMultipleRulesetsResponseDataAttributes, + > = None; + let mut id: Option = None; + let mut type_: Option< + crate::datadogV2::model::GetMultipleRulesetsResponseDataType, + > = 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() { + "attributes" => { + if v.is_null() { + continue; + } + attributes = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "id" => { + if v.is_null() { + continue; + } + id = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "type" => { + type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _type_) = type_ { + match _type_ { + crate::datadogV2::model::GetMultipleRulesetsResponseDataType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?; + + let content = GetMultipleRulesetsResponseData { + attributes, + id, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(GetMultipleRulesetsResponseDataVisitor) + } +} diff --git a/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes.rs b/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes.rs new file mode 100644 index 000000000..5bd6475dc --- /dev/null +++ b/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes.rs @@ -0,0 +1,108 @@ +// 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}; + +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct GetMultipleRulesetsResponseDataAttributes { + #[serde(rename = "rulesets")] + pub rulesets: Option< + Vec, + >, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl GetMultipleRulesetsResponseDataAttributes { + pub fn new() -> GetMultipleRulesetsResponseDataAttributes { + GetMultipleRulesetsResponseDataAttributes { + rulesets: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn rulesets( + mut self, + value: Vec, + ) -> Self { + self.rulesets = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for GetMultipleRulesetsResponseDataAttributes { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for GetMultipleRulesetsResponseDataAttributes { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct GetMultipleRulesetsResponseDataAttributesVisitor; + impl<'a> Visitor<'a> for GetMultipleRulesetsResponseDataAttributesVisitor { + type Value = GetMultipleRulesetsResponseDataAttributes; + + 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 rulesets: 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() { + "rulesets" => { + if v.is_null() { + continue; + } + rulesets = 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 content = GetMultipleRulesetsResponseDataAttributes { + rulesets, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(GetMultipleRulesetsResponseDataAttributesVisitor) + } +} diff --git a/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items.rs b/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items.rs new file mode 100644 index 000000000..9756b3b1b --- /dev/null +++ b/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items.rs @@ -0,0 +1,161 @@ +// 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}; + +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct GetMultipleRulesetsResponseDataAttributesRulesetsItems { + #[serde(rename = "data")] + pub data: crate::datadogV2::model::GetMultipleRulesetsResponseDataAttributesRulesetsItemsData, + #[serde(rename = "description")] + pub description: Option, + #[serde(rename = "name")] + pub name: Option, + #[serde(rename = "rules")] + pub rules: Option>, + #[serde(rename = "short_description")] + pub short_description: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool +} + +impl GetMultipleRulesetsResponseDataAttributesRulesetsItems { + pub fn new( + data: crate::datadogV2::model::GetMultipleRulesetsResponseDataAttributesRulesetsItemsData, + ) -> GetMultipleRulesetsResponseDataAttributesRulesetsItems { + GetMultipleRulesetsResponseDataAttributesRulesetsItems { + data, + description: None, + name: None, + rules: None, + short_description: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn description(mut self, value: String) -> Self { + self.description = Some(value); + self + } + + pub fn name(mut self, value: String) -> Self { + self.name = Some(value); + self + } + + pub fn rules( + mut self, + value: Vec, + ) -> Self { + self.rules = Some(value); + self + } + + pub fn short_description(mut self, value: String) -> Self { + self.short_description = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for GetMultipleRulesetsResponseDataAttributesRulesetsItems { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct GetMultipleRulesetsResponseDataAttributesRulesetsItemsVisitor; + impl<'a> Visitor<'a> for GetMultipleRulesetsResponseDataAttributesRulesetsItemsVisitor { + type Value = GetMultipleRulesetsResponseDataAttributesRulesetsItems; + + 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 data: Option = None; + let mut description: Option = None; + let mut name: Option = None; + let mut rules: Option> = None; + let mut short_description: 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() { + "data" => { + data = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "description" => { + if v.is_null() { + continue; + } + description = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "name" => { + if v.is_null() { + continue; + } + name = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "rules" => { + if v.is_null() { + continue; + } + rules = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "short_description" => { + if v.is_null() { + continue; + } + short_description = + 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 data = data.ok_or_else(|| M::Error::missing_field("data"))?; + + let content = GetMultipleRulesetsResponseDataAttributesRulesetsItems { + data, + description, + name, + rules, + short_description, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(GetMultipleRulesetsResponseDataAttributesRulesetsItemsVisitor) + } +} diff --git a/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_data.rs b/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_data.rs new file mode 100644 index 000000000..92abddccd --- /dev/null +++ b/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_data.rs @@ -0,0 +1,119 @@ +// 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}; + +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct GetMultipleRulesetsResponseDataAttributesRulesetsItemsData { + #[serde(rename = "id")] + pub id: Option, + /// Rulesets resource type. + #[serde(rename = "type")] + pub type_: + crate::datadogV2::model::GetMultipleRulesetsResponseDataAttributesRulesetsItemsDataType, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl GetMultipleRulesetsResponseDataAttributesRulesetsItemsData { + pub fn new( + type_: crate::datadogV2::model::GetMultipleRulesetsResponseDataAttributesRulesetsItemsDataType, + ) -> GetMultipleRulesetsResponseDataAttributesRulesetsItemsData { + GetMultipleRulesetsResponseDataAttributesRulesetsItemsData { + id: None, + type_, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn id(mut self, value: String) -> Self { + self.id = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for GetMultipleRulesetsResponseDataAttributesRulesetsItemsData { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct GetMultipleRulesetsResponseDataAttributesRulesetsItemsDataVisitor; + impl<'a> Visitor<'a> for GetMultipleRulesetsResponseDataAttributesRulesetsItemsDataVisitor { + type Value = GetMultipleRulesetsResponseDataAttributesRulesetsItemsData; + + 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 id: Option = None; + let mut type_: 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() { + "id" => { + if v.is_null() { + continue; + } + id = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "type" => { + type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _type_) = type_ { + match _type_ { + crate::datadogV2::model::GetMultipleRulesetsResponseDataAttributesRulesetsItemsDataType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?; + + let content = GetMultipleRulesetsResponseDataAttributesRulesetsItemsData { + id, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer + .deserialize_any(GetMultipleRulesetsResponseDataAttributesRulesetsItemsDataVisitor) + } +} diff --git a/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_data_type.rs b/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_data_type.rs new file mode 100644 index 000000000..e9d79b6e7 --- /dev/null +++ b/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_data_type.rs @@ -0,0 +1,48 @@ +// 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::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum GetMultipleRulesetsResponseDataAttributesRulesetsItemsDataType { + RULESETS, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for GetMultipleRulesetsResponseDataAttributesRulesetsItemsDataType { + fn to_string(&self) -> String { + match self { + Self::RULESETS => String::from("rulesets"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for GetMultipleRulesetsResponseDataAttributesRulesetsItemsDataType { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for GetMultipleRulesetsResponseDataAttributesRulesetsItemsDataType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "rulesets" => Self::RULESETS, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items.rs b/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items.rs new file mode 100644 index 000000000..f8bd07941 --- /dev/null +++ b/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items.rs @@ -0,0 +1,493 @@ +// 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}; + +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItems { + #[serde(rename = "arguments")] + pub arguments: Option>, + #[serde(rename = "category")] + pub category: Option, + #[serde(rename = "checksum")] + pub checksum: Option, + #[serde(rename = "code")] + pub code: Option, + #[serde(rename = "created_at")] + pub created_at: Option>, + #[serde(rename = "created_by")] + pub created_by: Option, + #[serde(rename = "cve")] + pub cve: Option, + #[serde(rename = "cwe")] + pub cwe: Option, + #[serde(rename = "data")] + pub data: crate::datadogV2::model::GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsData, + #[serde(rename = "description")] + pub description: Option, + #[serde(rename = "documentation_url")] + pub documentation_url: Option, + #[serde(rename = "entity_checked")] + pub entity_checked: Option, + #[serde(rename = "is_published")] + pub is_published: Option, + #[serde(rename = "is_testing")] + pub is_testing: Option, + #[serde(rename = "language")] + pub language: Option, + #[serde(rename = "last_updated_at")] + pub last_updated_at: Option>, + #[serde(rename = "last_updated_by")] + pub last_updated_by: Option, + #[serde(rename = "name")] + pub name: Option, + #[serde(rename = "regex")] + pub regex: Option, + #[serde(rename = "severity")] + pub severity: Option, + #[serde(rename = "short_description")] + pub short_description: Option, + #[serde(rename = "should_use_ai_fix")] + pub should_use_ai_fix: Option, + #[serde(rename = "tests")] + pub tests: Option>, + #[serde(rename = "tree_sitter_query")] + pub tree_sitter_query: Option, + #[serde(rename = "type")] + pub type_: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool +} + +impl GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItems { + pub fn new( + data: crate::datadogV2::model::GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsData, + ) -> GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItems { + GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItems { + arguments: None, + category: None, + checksum: None, + code: None, + created_at: None, + created_by: None, + cve: None, + cwe: None, + data, + description: None, + documentation_url: None, + entity_checked: None, + is_published: None, + is_testing: None, + language: None, + last_updated_at: None, + last_updated_by: None, + name: None, + regex: None, + severity: None, + short_description: None, + should_use_ai_fix: None, + tests: None, + tree_sitter_query: None, + type_: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn arguments( + mut self, + value: Vec, + ) -> Self { + self.arguments = Some(value); + self + } + + pub fn category(mut self, value: String) -> Self { + self.category = Some(value); + self + } + + pub fn checksum(mut self, value: String) -> Self { + self.checksum = Some(value); + self + } + + pub fn code(mut self, value: String) -> Self { + self.code = Some(value); + self + } + + pub fn created_at(mut self, value: chrono::DateTime) -> Self { + self.created_at = Some(value); + self + } + + pub fn created_by(mut self, value: String) -> Self { + self.created_by = Some(value); + self + } + + pub fn cve(mut self, value: String) -> Self { + self.cve = Some(value); + self + } + + pub fn cwe(mut self, value: String) -> Self { + self.cwe = Some(value); + self + } + + pub fn description(mut self, value: String) -> Self { + self.description = Some(value); + self + } + + pub fn documentation_url(mut self, value: String) -> Self { + self.documentation_url = Some(value); + self + } + + pub fn entity_checked(mut self, value: String) -> Self { + self.entity_checked = Some(value); + self + } + + pub fn is_published(mut self, value: bool) -> Self { + self.is_published = Some(value); + self + } + + pub fn is_testing(mut self, value: bool) -> Self { + self.is_testing = Some(value); + self + } + + pub fn language(mut self, value: String) -> Self { + self.language = Some(value); + self + } + + pub fn last_updated_at(mut self, value: chrono::DateTime) -> Self { + self.last_updated_at = Some(value); + self + } + + pub fn last_updated_by(mut self, value: String) -> Self { + self.last_updated_by = Some(value); + self + } + + pub fn name(mut self, value: String) -> Self { + self.name = Some(value); + self + } + + pub fn regex(mut self, value: String) -> Self { + self.regex = Some(value); + self + } + + pub fn severity(mut self, value: String) -> Self { + self.severity = Some(value); + self + } + + pub fn short_description(mut self, value: String) -> Self { + self.short_description = Some(value); + self + } + + pub fn should_use_ai_fix(mut self, value: bool) -> Self { + self.should_use_ai_fix = Some(value); + self + } + + pub fn tests( + mut self, + value: Vec, + ) -> Self { + self.tests = Some(value); + self + } + + pub fn tree_sitter_query(mut self, value: String) -> Self { + self.tree_sitter_query = Some(value); + self + } + + pub fn type_(mut self, value: String) -> Self { + self.type_ = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItems { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsVisitor; + impl<'a> Visitor<'a> for GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsVisitor { + type Value = GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItems; + + 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 arguments: Option> = None; + let mut category: Option = None; + let mut checksum: Option = None; + let mut code: Option = None; + let mut created_at: Option> = None; + let mut created_by: Option = None; + let mut cve: Option = None; + let mut cwe: Option = None; + let mut data: Option = None; + let mut description: Option = None; + let mut documentation_url: Option = None; + let mut entity_checked: Option = None; + let mut is_published: Option = None; + let mut is_testing: Option = None; + let mut language: Option = None; + let mut last_updated_at: Option> = None; + let mut last_updated_by: Option = None; + let mut name: Option = None; + let mut regex: Option = None; + let mut severity: Option = None; + let mut short_description: Option = None; + let mut should_use_ai_fix: Option = None; + let mut tests: Option> = None; + let mut tree_sitter_query: Option = None; + let mut type_: 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() { + "arguments" => { + if v.is_null() { + continue; + } + arguments = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "category" => { + if v.is_null() { + continue; + } + category = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "checksum" => { + if v.is_null() { + continue; + } + checksum = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "code" => { + if v.is_null() { + continue; + } + code = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "created_at" => { + if v.is_null() { + continue; + } + created_at = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "created_by" => { + if v.is_null() { + continue; + } + created_by = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "cve" => { + if v.is_null() { + continue; + } + cve = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "cwe" => { + if v.is_null() { + continue; + } + cwe = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "data" => { + data = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "description" => { + if v.is_null() { + continue; + } + description = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "documentation_url" => { + if v.is_null() { + continue; + } + documentation_url = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "entity_checked" => { + if v.is_null() { + continue; + } + entity_checked = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "is_published" => { + if v.is_null() { + continue; + } + is_published = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "is_testing" => { + if v.is_null() { + continue; + } + is_testing = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "language" => { + if v.is_null() { + continue; + } + language = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "last_updated_at" => { + if v.is_null() { + continue; + } + last_updated_at = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "last_updated_by" => { + if v.is_null() { + continue; + } + last_updated_by = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "name" => { + if v.is_null() { + continue; + } + name = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "regex" => { + if v.is_null() { + continue; + } + regex = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "severity" => { + if v.is_null() { + continue; + } + severity = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "short_description" => { + if v.is_null() { + continue; + } + short_description = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "should_use_ai_fix" => { + if v.is_null() { + continue; + } + should_use_ai_fix = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "tests" => { + if v.is_null() { + continue; + } + tests = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "tree_sitter_query" => { + if v.is_null() { + continue; + } + tree_sitter_query = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "type" => { + if v.is_null() { + continue; + } + type_ = 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 data = data.ok_or_else(|| M::Error::missing_field("data"))?; + + let content = GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItems { + arguments, + category, + checksum, + code, + created_at, + created_by, + cve, + cwe, + data, + description, + documentation_url, + entity_checked, + is_published, + is_testing, + language, + last_updated_at, + last_updated_by, + name, + regex, + severity, + short_description, + should_use_ai_fix, + tests, + tree_sitter_query, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any( + GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsVisitor, + ) + } +} diff --git a/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items_arguments_items.rs b/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items_arguments_items.rs new file mode 100644 index 000000000..8f8969440 --- /dev/null +++ b/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items_arguments_items.rs @@ -0,0 +1,120 @@ +// 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}; + +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsArgumentsItems { + #[serde(rename = "description")] + pub description: Option, + #[serde(rename = "name")] + pub name: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsArgumentsItems { + pub fn new() -> GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsArgumentsItems { + GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsArgumentsItems { + description: None, + name: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn description(mut self, value: String) -> Self { + self.description = Some(value); + self + } + + pub fn name(mut self, value: String) -> Self { + self.name = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsArgumentsItems { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> + for GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsArgumentsItems +{ + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsArgumentsItemsVisitor; + impl<'a> Visitor<'a> for GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsArgumentsItemsVisitor { + type Value = GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsArgumentsItems; + + 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 name: Option = None; + let mut additional_properties: std::collections::BTreeMap = 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)?); + }, + "name" => { + if v.is_null() { + continue; + } + 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 content = GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsArgumentsItems { + description, + name, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any( + GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsArgumentsItemsVisitor, + ) + } +} diff --git a/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items_data.rs b/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items_data.rs new file mode 100644 index 000000000..6b21f6f00 --- /dev/null +++ b/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items_data.rs @@ -0,0 +1,124 @@ +// 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}; + +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsData { + #[serde(rename = "id")] + pub id: Option, + /// Rules resource type. + #[serde(rename = "type")] + pub type_: crate::datadogV2::model::GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsDataType, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool +} + +impl GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsData { + pub fn new( + type_: crate::datadogV2::model::GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsDataType, + ) -> GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsData { + GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsData { + id: None, + type_, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn id(mut self, value: String) -> Self { + self.id = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> + for GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsData +{ + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsDataVisitor; + impl<'a> Visitor<'a> + for GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsDataVisitor + { + type Value = GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsData; + + 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 id: Option = None; + let mut type_: 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() { + "id" => { + if v.is_null() { + continue; + } + id = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "type" => { + type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _type_) = type_ { + match _type_ { + crate::datadogV2::model::GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsDataType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?; + + let content = + GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsData { + id, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any( + GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsDataVisitor, + ) + } +} diff --git a/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items_data_type.rs b/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items_data_type.rs new file mode 100644 index 000000000..281c5a408 --- /dev/null +++ b/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items_data_type.rs @@ -0,0 +1,50 @@ +// 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::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsDataType { + RULES, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsDataType { + fn to_string(&self) -> String { + match self { + Self::RULES => String::from("rules"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsDataType { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> + for GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsDataType +{ + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "rules" => Self::RULES, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items_tests_items.rs b/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items_tests_items.rs new file mode 100644 index 000000000..8072d490d --- /dev/null +++ b/src/datadogV2/model/model_get_multiple_rulesets_response_data_attributes_rulesets_items_rules_items_tests_items.rs @@ -0,0 +1,143 @@ +// 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}; + +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsTestsItems { + #[serde(rename = "annotation_count")] + pub annotation_count: Option, + #[serde(rename = "code")] + pub code: Option, + #[serde(rename = "filename")] + pub filename: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsTestsItems { + pub fn new() -> GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsTestsItems { + GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsTestsItems { + annotation_count: None, + code: None, + filename: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn annotation_count(mut self, value: i64) -> Self { + self.annotation_count = Some(value); + self + } + + pub fn code(mut self, value: String) -> Self { + self.code = Some(value); + self + } + + pub fn filename(mut self, value: String) -> Self { + self.filename = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsTestsItems { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> + for GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsTestsItems +{ + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsTestsItemsVisitor; + impl<'a> Visitor<'a> + for GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsTestsItemsVisitor + { + type Value = GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsTestsItems; + + 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 annotation_count: Option = None; + let mut code: Option = None; + let mut filename: 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() { + "annotation_count" => { + if v.is_null() { + continue; + } + annotation_count = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "code" => { + if v.is_null() { + continue; + } + code = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "filename" => { + if v.is_null() { + continue; + } + filename = 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 content = + GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsTestsItems { + annotation_count, + code, + filename, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any( + GetMultipleRulesetsResponseDataAttributesRulesetsItemsRulesItemsTestsItemsVisitor, + ) + } +} diff --git a/src/datadogV2/model/model_get_multiple_rulesets_response_data_type.rs b/src/datadogV2/model/model_get_multiple_rulesets_response_data_type.rs new file mode 100644 index 000000000..764ccf13d --- /dev/null +++ b/src/datadogV2/model/model_get_multiple_rulesets_response_data_type.rs @@ -0,0 +1,48 @@ +// 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::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum GetMultipleRulesetsResponseDataType { + GET_MULTIPLE_RULESETS_RESPONSE, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for GetMultipleRulesetsResponseDataType { + fn to_string(&self) -> String { + match self { + Self::GET_MULTIPLE_RULESETS_RESPONSE => String::from("get_multiple_rulesets_response"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for GetMultipleRulesetsResponseDataType { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for GetMultipleRulesetsResponseDataType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "get_multiple_rulesets_response" => Self::GET_MULTIPLE_RULESETS_RESPONSE, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_secret_rule_array.rs b/src/datadogV2/model/model_secret_rule_array.rs new file mode 100644 index 000000000..97a90a1b2 --- /dev/null +++ b/src/datadogV2/model/model_secret_rule_array.rs @@ -0,0 +1,90 @@ +// 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}; + +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct SecretRuleArray { + #[serde(rename = "data")] + pub data: Vec, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl SecretRuleArray { + pub fn new(data: Vec) -> SecretRuleArray { + SecretRuleArray { + data, + 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 SecretRuleArray { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct SecretRuleArrayVisitor; + impl<'a> Visitor<'a> for SecretRuleArrayVisitor { + type Value = SecretRuleArray; + + 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 data: 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() { + "data" => { + data = 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 data = data.ok_or_else(|| M::Error::missing_field("data"))?; + + let content = SecretRuleArray { + data, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(SecretRuleArrayVisitor) + } +} diff --git a/src/datadogV2/model/model_secret_rule_data.rs b/src/datadogV2/model/model_secret_rule_data.rs new file mode 100644 index 000000000..899469514 --- /dev/null +++ b/src/datadogV2/model/model_secret_rule_data.rs @@ -0,0 +1,134 @@ +// 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}; + +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct SecretRuleData { + #[serde(rename = "attributes")] + pub attributes: Option, + #[serde(rename = "id")] + pub id: Option, + /// Secret rule resource type. + #[serde(rename = "type")] + pub type_: crate::datadogV2::model::SecretRuleDataType, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl SecretRuleData { + pub fn new(type_: crate::datadogV2::model::SecretRuleDataType) -> SecretRuleData { + SecretRuleData { + attributes: None, + id: None, + type_, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn attributes(mut self, value: crate::datadogV2::model::SecretRuleDataAttributes) -> Self { + self.attributes = Some(value); + self + } + + pub fn id(mut self, value: String) -> Self { + self.id = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for SecretRuleData { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct SecretRuleDataVisitor; + impl<'a> Visitor<'a> for SecretRuleDataVisitor { + type Value = SecretRuleData; + + 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 attributes: Option = + None; + let mut id: Option = None; + let mut type_: 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() { + "attributes" => { + if v.is_null() { + continue; + } + attributes = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "id" => { + if v.is_null() { + continue; + } + id = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "type" => { + type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _type_) = type_ { + match _type_ { + crate::datadogV2::model::SecretRuleDataType::UnparsedObject( + _type_, + ) => { + _unparsed = true; + } + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?; + + let content = SecretRuleData { + attributes, + id, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(SecretRuleDataVisitor) + } +} diff --git a/src/datadogV2/model/model_secret_rule_data_attributes.rs b/src/datadogV2/model/model_secret_rule_data_attributes.rs new file mode 100644 index 000000000..0ddfe233a --- /dev/null +++ b/src/datadogV2/model/model_secret_rule_data_attributes.rs @@ -0,0 +1,239 @@ +// 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}; + +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct SecretRuleDataAttributes { + #[serde(rename = "default_included_keywords")] + pub default_included_keywords: Option>, + #[serde(rename = "description")] + pub description: Option, + #[serde(rename = "license")] + pub license: Option, + #[serde(rename = "match_validation")] + pub match_validation: Option, + #[serde(rename = "name")] + pub name: Option, + #[serde(rename = "pattern")] + pub pattern: Option, + #[serde(rename = "priority")] + pub priority: Option, + #[serde(rename = "sds_id")] + pub sds_id: Option, + #[serde(rename = "validators")] + pub validators: Option>, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl SecretRuleDataAttributes { + pub fn new() -> SecretRuleDataAttributes { + SecretRuleDataAttributes { + default_included_keywords: None, + description: None, + license: None, + match_validation: None, + name: None, + pattern: None, + priority: None, + sds_id: None, + validators: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn default_included_keywords(mut self, value: Vec) -> Self { + self.default_included_keywords = Some(value); + self + } + + pub fn description(mut self, value: String) -> Self { + self.description = Some(value); + self + } + + pub fn license(mut self, value: String) -> Self { + self.license = Some(value); + self + } + + pub fn match_validation( + mut self, + value: crate::datadogV2::model::SecretRuleDataAttributesMatchValidation, + ) -> Self { + self.match_validation = Some(value); + self + } + + pub fn name(mut self, value: String) -> Self { + self.name = Some(value); + self + } + + pub fn pattern(mut self, value: String) -> Self { + self.pattern = Some(value); + self + } + + pub fn priority(mut self, value: String) -> Self { + self.priority = Some(value); + self + } + + pub fn sds_id(mut self, value: String) -> Self { + self.sds_id = Some(value); + self + } + + pub fn validators(mut self, value: Vec) -> Self { + self.validators = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for SecretRuleDataAttributes { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for SecretRuleDataAttributes { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct SecretRuleDataAttributesVisitor; + impl<'a> Visitor<'a> for SecretRuleDataAttributesVisitor { + type Value = SecretRuleDataAttributes; + + 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 default_included_keywords: Option> = None; + let mut description: Option = None; + let mut license: Option = None; + let mut match_validation: Option< + crate::datadogV2::model::SecretRuleDataAttributesMatchValidation, + > = None; + let mut name: Option = None; + let mut pattern: Option = None; + let mut priority: Option = None; + let mut sds_id: Option = None; + let mut validators: 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() { + "default_included_keywords" => { + if v.is_null() { + continue; + } + default_included_keywords = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "description" => { + if v.is_null() { + continue; + } + description = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "license" => { + if v.is_null() { + continue; + } + license = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "match_validation" => { + if v.is_null() { + continue; + } + match_validation = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "name" => { + if v.is_null() { + continue; + } + name = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "pattern" => { + if v.is_null() { + continue; + } + pattern = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "priority" => { + if v.is_null() { + continue; + } + priority = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "sds_id" => { + if v.is_null() { + continue; + } + sds_id = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "validators" => { + if v.is_null() { + continue; + } + validators = 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 content = SecretRuleDataAttributes { + default_included_keywords, + description, + license, + match_validation, + name, + pattern, + priority, + sds_id, + validators, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(SecretRuleDataAttributesVisitor) + } +} diff --git a/src/datadogV2/model/model_secret_rule_data_attributes_match_validation.rs b/src/datadogV2/model/model_secret_rule_data_attributes_match_validation.rs new file mode 100644 index 000000000..a3f157e5b --- /dev/null +++ b/src/datadogV2/model/model_secret_rule_data_attributes_match_validation.rs @@ -0,0 +1,226 @@ +// 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}; + +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct SecretRuleDataAttributesMatchValidation { + #[serde(rename = "endpoint")] + pub endpoint: Option, + #[serde(rename = "hosts")] + pub hosts: Option>, + #[serde(rename = "http_method")] + pub http_method: Option, + #[serde(rename = "invalid_http_status_code")] + pub invalid_http_status_code: Option>, + #[serde(rename = "request_headers")] + pub request_headers: Option>, + #[serde(rename = "timeout_seconds")] + pub timeout_seconds: Option, + #[serde(rename = "type")] + pub type_: Option, + #[serde(rename = "valid_http_status_code")] + pub valid_http_status_code: Option>, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool +} + +impl SecretRuleDataAttributesMatchValidation { + pub fn new() -> SecretRuleDataAttributesMatchValidation { + SecretRuleDataAttributesMatchValidation { + endpoint: None, + hosts: None, + http_method: None, + invalid_http_status_code: None, + request_headers: None, + timeout_seconds: None, + type_: None, + valid_http_status_code: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn endpoint(mut self, value: String) -> Self { + self.endpoint = Some(value); + self + } + + pub fn hosts(mut self, value: Vec) -> Self { + self.hosts = Some(value); + self + } + + pub fn http_method(mut self, value: String) -> Self { + self.http_method = Some(value); + self + } + + pub fn invalid_http_status_code( + mut self, + value: Vec, + ) -> Self { + self.invalid_http_status_code = Some(value); + self + } + + pub fn request_headers(mut self, value: std::collections::BTreeMap) -> Self { + self.request_headers = Some(value); + self + } + + pub fn timeout_seconds(mut self, value: i64) -> Self { + self.timeout_seconds = Some(value); + self + } + + pub fn type_(mut self, value: String) -> Self { + self.type_ = Some(value); + self + } + + pub fn valid_http_status_code( + mut self, + value: Vec, + ) -> Self { + self.valid_http_status_code = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for SecretRuleDataAttributesMatchValidation { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for SecretRuleDataAttributesMatchValidation { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct SecretRuleDataAttributesMatchValidationVisitor; + impl<'a> Visitor<'a> for SecretRuleDataAttributesMatchValidationVisitor { + type Value = SecretRuleDataAttributesMatchValidation; + + 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 endpoint: Option = None; + let mut hosts: Option> = None; + let mut http_method: Option = None; + let mut invalid_http_status_code: Option> = None; + let mut request_headers: Option> = None; + let mut timeout_seconds: Option = None; + let mut type_: Option = None; + let mut valid_http_status_code: 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() { + "endpoint" => { + if v.is_null() { + continue; + } + endpoint = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "hosts" => { + if v.is_null() { + continue; + } + hosts = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "http_method" => { + if v.is_null() { + continue; + } + http_method = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "invalid_http_status_code" => { + if v.is_null() { + continue; + } + invalid_http_status_code = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "request_headers" => { + if v.is_null() { + continue; + } + request_headers = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "timeout_seconds" => { + if v.is_null() { + continue; + } + timeout_seconds = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "type" => { + if v.is_null() { + continue; + } + type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "valid_http_status_code" => { + if v.is_null() { + continue; + } + valid_http_status_code = + 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 content = SecretRuleDataAttributesMatchValidation { + endpoint, + hosts, + http_method, + invalid_http_status_code, + request_headers, + timeout_seconds, + type_, + valid_http_status_code, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(SecretRuleDataAttributesMatchValidationVisitor) + } +} diff --git a/src/datadogV2/model/model_secret_rule_data_attributes_match_validation_invalid_http_status_code_items.rs b/src/datadogV2/model/model_secret_rule_data_attributes_match_validation_invalid_http_status_code_items.rs new file mode 100644 index 000000000..7e6eab0ca --- /dev/null +++ b/src/datadogV2/model/model_secret_rule_data_attributes_match_validation_invalid_http_status_code_items.rs @@ -0,0 +1,121 @@ +// 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}; + +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct SecretRuleDataAttributesMatchValidationInvalidHttpStatusCodeItems { + #[serde(rename = "end")] + pub end: Option, + #[serde(rename = "start")] + pub start: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl SecretRuleDataAttributesMatchValidationInvalidHttpStatusCodeItems { + pub fn new() -> SecretRuleDataAttributesMatchValidationInvalidHttpStatusCodeItems { + SecretRuleDataAttributesMatchValidationInvalidHttpStatusCodeItems { + end: None, + start: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn end(mut self, value: i64) -> Self { + self.end = Some(value); + self + } + + pub fn start(mut self, value: i64) -> Self { + self.start = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for SecretRuleDataAttributesMatchValidationInvalidHttpStatusCodeItems { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for SecretRuleDataAttributesMatchValidationInvalidHttpStatusCodeItems { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct SecretRuleDataAttributesMatchValidationInvalidHttpStatusCodeItemsVisitor; + impl<'a> Visitor<'a> for SecretRuleDataAttributesMatchValidationInvalidHttpStatusCodeItemsVisitor { + type Value = SecretRuleDataAttributesMatchValidationInvalidHttpStatusCodeItems; + + 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 end: Option = None; + let mut start: 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() { + "end" => { + if v.is_null() { + continue; + } + end = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "start" => { + if v.is_null() { + continue; + } + start = 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 content = SecretRuleDataAttributesMatchValidationInvalidHttpStatusCodeItems { + end, + start, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any( + SecretRuleDataAttributesMatchValidationInvalidHttpStatusCodeItemsVisitor, + ) + } +} diff --git a/src/datadogV2/model/model_secret_rule_data_attributes_match_validation_valid_http_status_code_items.rs b/src/datadogV2/model/model_secret_rule_data_attributes_match_validation_valid_http_status_code_items.rs new file mode 100644 index 000000000..84e89e16f --- /dev/null +++ b/src/datadogV2/model/model_secret_rule_data_attributes_match_validation_valid_http_status_code_items.rs @@ -0,0 +1,120 @@ +// 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}; + +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct SecretRuleDataAttributesMatchValidationValidHttpStatusCodeItems { + #[serde(rename = "end")] + pub end: Option, + #[serde(rename = "start")] + pub start: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl SecretRuleDataAttributesMatchValidationValidHttpStatusCodeItems { + pub fn new() -> SecretRuleDataAttributesMatchValidationValidHttpStatusCodeItems { + SecretRuleDataAttributesMatchValidationValidHttpStatusCodeItems { + end: None, + start: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn end(mut self, value: i64) -> Self { + self.end = Some(value); + self + } + + pub fn start(mut self, value: i64) -> Self { + self.start = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for SecretRuleDataAttributesMatchValidationValidHttpStatusCodeItems { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for SecretRuleDataAttributesMatchValidationValidHttpStatusCodeItems { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct SecretRuleDataAttributesMatchValidationValidHttpStatusCodeItemsVisitor; + impl<'a> Visitor<'a> for SecretRuleDataAttributesMatchValidationValidHttpStatusCodeItemsVisitor { + type Value = SecretRuleDataAttributesMatchValidationValidHttpStatusCodeItems; + + 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 end: Option = None; + let mut start: 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() { + "end" => { + if v.is_null() { + continue; + } + end = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "start" => { + if v.is_null() { + continue; + } + start = 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 content = SecretRuleDataAttributesMatchValidationValidHttpStatusCodeItems { + end, + start, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer + .deserialize_any(SecretRuleDataAttributesMatchValidationValidHttpStatusCodeItemsVisitor) + } +} diff --git a/src/datadogV2/model/model_secret_rule_data_type.rs b/src/datadogV2/model/model_secret_rule_data_type.rs new file mode 100644 index 000000000..c9d58136b --- /dev/null +++ b/src/datadogV2/model/model_secret_rule_data_type.rs @@ -0,0 +1,48 @@ +// 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::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum SecretRuleDataType { + SECRET_RULE, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for SecretRuleDataType { + fn to_string(&self) -> String { + match self { + Self::SECRET_RULE => String::from("secret_rule"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for SecretRuleDataType { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for SecretRuleDataType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "secret_rule" => Self::SECRET_RULE, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/tests/scenarios/features/v2/security_monitoring.feature b/tests/scenarios/features/v2/security_monitoring.feature index 703fc3e46..2937151ef 100644 --- a/tests/scenarios/features/v2/security_monitoring.feature +++ b/tests/scenarios/features/v2/security_monitoring.feature @@ -5,9 +5,9 @@ Feature: Security Monitoring information. Background: - Given a valid "apiKeyAuth" key in the system + Given an instance of "SecurityMonitoring" API + And a valid "apiKeyAuth" key in the system And a valid "appKeyAuth" key in the system - And an instance of "SecurityMonitoring" API @team:DataDog/k9-cloud-security-platform Scenario: Cancel a historical job returns "Bad Request" response @@ -1295,6 +1295,21 @@ Feature: Security Monitoring When the request is sent Then the response status is 422 The server cannot process the request because it contains invalid data. + @generated @skip @team:DataDog/asm-vm + Scenario: Returns list of Secrets rules returns "OK" response + Given operation "GetSecretsRules" enabled + And new "GetSecretsRules" request + When the request is sent + Then the response status is 200 OK + + @generated @skip @team:DataDog/asm-vm + Scenario: Ruleset get multiple returns "OK" response + Given operation "ListMultipleRulesets" enabled + And new "ListMultipleRulesets" request + And body with value {"data": {"attributes": {"rulesets": []}, "type": "get_multiple_rulesets_request"}} + When the request is sent + Then the response status is 200 OK + @team:DataDog/k9-cloud-security-platform Scenario: Run a threat hunting job returns "Bad Request" response Given operation "RunThreatHuntingJob" enabled diff --git a/tests/scenarios/features/v2/undo.json b/tests/scenarios/features/v2/undo.json index eb1380ab6..cd58e7f6d 100644 --- a/tests/scenarios/features/v2/undo.json +++ b/tests/scenarios/features/v2/undo.json @@ -4005,6 +4005,20 @@ "type": "safe" } }, + "ListMultipleRulesets": { + "tag": "Security Monitoring", + "undo": { + "operationId": "TODO", + "parameters": [], + "type": "unsafe" + } + }, + "GetSecretsRules": { + "tag": "Security Monitoring", + "undo": { + "type": "safe" + } + }, "GetOnDemandConcurrencyCap": { "tag": "Synthetics", "undo": { diff --git a/tests/scenarios/function_mappings.rs b/tests/scenarios/function_mappings.rs index baca98d96..df21b2935 100644 --- a/tests/scenarios/function_mappings.rs +++ b/tests/scenarios/function_mappings.rs @@ -2547,6 +2547,13 @@ pub fn collect_function_calls(world: &mut DatadogWorld) { "v2.GetSecurityMonitoringHistsignalsByJobId".into(), test_v2_get_security_monitoring_histsignals_by_job_id, ); + world.function_mappings.insert( + "v2.ListMultipleRulesets".into(), + test_v2_list_multiple_rulesets, + ); + world + .function_mappings + .insert("v2.GetSecretsRules".into(), test_v2_get_secrets_rules); world.function_mappings.insert( "v2.ListContainerImages".into(), test_v2_list_container_images, @@ -18355,6 +18362,55 @@ fn test_v2_get_security_monitoring_histsignals_by_job_id( world.response.code = response.status.as_u16(); } +fn test_v2_list_multiple_rulesets(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.list_multiple_rulesets_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_secrets_rules(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.get_secrets_rules_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(); +} + fn test_v2_list_container_images(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances