datadog_api_client 2.23.0 → 2.24.0

data/.generator/src/generator/replacement.json

@@ -1 +1 @@
-{"IdP": "Idp", "AuthNMapping": "AuthnMapping", "AuthN ": "Authn ", "IoT": "Iot", "SLOs": "Slos"}
+{"IdP": "Idp", "AuthNMapping": "AuthnMapping", "AuthN ": "Authn ", "IoT": "Iot", "SLOs": "Slos", "APIs": "Apis"}

data/.github/CODEOWNERS

@@ -3,10 +3,10 @@
 # and another team can own the rest of the directory.
 
 # All your base
-*                       @DataDog/integrations-tools-and-libraries
+*                       @DataDog/api-clients
 
 # Documentation
-*.md                    @DataDog/baklava @DataDog/integrations-tools-and-libraries
-LICENSE                 @DataDog/baklava @DataDog/integrations-tools-and-libraries
-NOTICE                  @DataDog/baklava @DataDog/integrations-tools-and-libraries
-LICENSE-3rdparty.csv    @DataDog/baklava @DataDog/integrations-tools-and-libraries
+*.md                    @DataDog/documentation @DataDog/api-clients
+LICENSE                 @DataDog/documentation @DataDog/api-clients
+NOTICE                  @DataDog/documentation @DataDog/api-clients
+LICENSE-3rdparty.csv    @DataDog/documentation @DataDog/api-clients

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 # CHANGELOG
 
+## 2.24.0 / 2024-07-01
+
+### Fixed
+* Security Monitoring - Define specific payload for rule validation/testing by @api-clients-generation-pipeline in https://github.com/DataDog/datadog-api-client-ruby/pull/1843
+* Remove the maximum limitation for the synthetics renotify_interval monitor option by @api-clients-generation-pipeline in https://github.com/DataDog/datadog-api-client-ruby/pull/1847
+* Add bodyHash as a synthetics assertion type. by @api-clients-generation-pipeline in https://github.com/DataDog/datadog-api-client-ruby/pull/1848
+* Add missing attributes envelope in ListAPIs response by @api-clients-generation-pipeline in https://github.com/DataDog/datadog-api-client-ruby/pull/1856
+### Added
+* Allow the usage of the filters field when creating an agent rule by @api-clients-generation-pipeline in https://github.com/DataDog/datadog-api-client-ruby/pull/1824
+* Add tileDef sort attribute by @api-clients-generation-pipeline in https://github.com/DataDog/datadog-api-client-ruby/pull/1826
+* Add Security Monitoring rule test endpoint by @api-clients-generation-pipeline in https://github.com/DataDog/datadog-api-client-ruby/pull/1839
+* Add originalFileName field to the SyntheticsTestRequestBodyFile definition by @api-clients-generation-pipeline in https://github.com/DataDog/datadog-api-client-ruby/pull/1844
+* Add support for API management ListAPIs by @api-clients-generation-pipeline in https://github.com/DataDog/datadog-api-client-ruby/pull/1851
+* Add elementsOperator to json path assertion for synthetic HTTP tests by @api-clients-generation-pipeline in https://github.com/DataDog/datadog-api-client-ruby/pull/1862
+* Add /api/v2/org_configs specs by @api-clients-generation-pipeline in https://github.com/DataDog/datadog-api-client-ruby/pull/1861
+* Update docs for RU Rollout New and Deprecated Keys planned for Oct 1st by @api-clients-generation-pipeline in https://github.com/DataDog/datadog-api-client-ruby/pull/1873
+* Add option for wait step in multistep api tests by @api-clients-generation-pipeline in https://github.com/DataDog/datadog-api-client-ruby/pull/1872
+### Changed
+* Monitor priority can have custom ranges and be null by @api-clients-generation-pipeline in https://github.com/DataDog/datadog-api-client-ruby/pull/1870
+
+## New Contributors
+* @tim-chaplin-dd made their first contribution in https://github.com/DataDog/datadog-api-client-ruby/pull/1784
+* @jack-edmonds-dd made their first contribution in https://github.com/DataDog/datadog-api-client-ruby/pull/1866
+
+**Full Changelog**: https://github.com/DataDog/datadog-api-client-ruby/compare/v2.23.0...v2.24.0
+
 ## 2.23.0 / 2024-05-22
 
 ### Fixed

data/examples/v1/dashboards/CreateDashboard_1213075383.rb

@@ -40,12 +40,18 @@ body = DatadogAPIClient::V1::Dashboard.new({
             formulas: [
               DatadogAPIClient::V1::WidgetFormula.new({
                 formula: "query1",
-                limit: DatadogAPIClient::V1::WidgetFormulaLimit.new({
-                  count: 10,
-                  order: DatadogAPIClient::V1::QuerySortOrder::DESC,
-                }),
               }),
             ],
+            sort: DatadogAPIClient::V1::WidgetSortBy.new({
+              count: 10,
+              order_by: [
+                DatadogAPIClient::V1::WidgetFormulaSort.new({
+                  type: DatadogAPIClient::V1::FormulaType::FORMULA,
+                  index: 0,
+                  order: DatadogAPIClient::V1::WidgetSort::DESCENDING,
+                }),
+              ],
+            }),
             response_format: DatadogAPIClient::V1::FormulaAndFunctionResponseFormat::SCALAR,
           }),
         ],

data/examples/v1/dashboards/CreateDashboard_2336428357.rb

@@ -33,14 +33,20 @@ body = DatadogAPIClient::V1::Dashboard.new({
             formulas: [
               DatadogAPIClient::V1::WidgetFormula.new({
                 formula: "query1",
-                limit: DatadogAPIClient::V1::WidgetFormulaLimit.new({
-                  count: 500,
-                  order: DatadogAPIClient::V1::QuerySortOrder::DESC,
-                }),
                 conditional_formats: [],
                 cell_display_mode: DatadogAPIClient::V1::TableWidgetCellDisplayMode::BAR,
               }),
             ],
+            sort: DatadogAPIClient::V1::WidgetSortBy.new({
+              count: 500,
+              order_by: [
+                DatadogAPIClient::V1::WidgetFormulaSort.new({
+                  type: DatadogAPIClient::V1::FormulaType::FORMULA,
+                  index: 0,
+                  order: DatadogAPIClient::V1::WidgetSort::DESCENDING,
+                }),
+              ],
+            }),
             response_format: DatadogAPIClient::V1::FormulaAndFunctionResponseFormat::SCALAR,
           }),
         ],

data/examples/v1/dashboards/CreateDashboard_2563642929.rb

@@ -0,0 +1,66 @@
+# Create a new dashboard with a toplist widget sorted by group
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V1::DashboardsAPI.new
+
+body = DatadogAPIClient::V1::Dashboard.new({
+  title: "Example-Dashboard",
+  description: "",
+  widgets: [
+    DatadogAPIClient::V1::Widget.new({
+      layout: DatadogAPIClient::V1::WidgetLayout.new({
+        x: 0,
+        y: 0,
+        width: 47,
+        height: 15,
+      }),
+      definition: DatadogAPIClient::V1::ToplistWidgetDefinition.new({
+        title: "",
+        title_size: "16",
+        title_align: DatadogAPIClient::V1::WidgetTextAlign::LEFT,
+        time: DatadogAPIClient::V1::WidgetTime.new({}),
+        style: DatadogAPIClient::V1::ToplistWidgetStyle.new({
+          display: DatadogAPIClient::V1::ToplistWidgetStacked.new({
+            type: DatadogAPIClient::V1::ToplistWidgetStackedType::STACKED,
+            legend: DatadogAPIClient::V1::ToplistWidgetLegend::INLINE,
+          }),
+          scaling: DatadogAPIClient::V1::ToplistWidgetScaling::RELATIVE,
+        }),
+        type: DatadogAPIClient::V1::ToplistWidgetDefinitionType::TOPLIST,
+        requests: [
+          DatadogAPIClient::V1::ToplistWidgetRequest.new({
+            queries: [
+              DatadogAPIClient::V1::FormulaAndFunctionMetricQueryDefinition.new({
+                data_source: DatadogAPIClient::V1::FormulaAndFunctionMetricDataSource::METRICS,
+                name: "query1",
+                query: "avg:system.cpu.user{*} by {service}",
+                aggregator: DatadogAPIClient::V1::FormulaAndFunctionMetricAggregation::AVG,
+              }),
+            ],
+            formulas: [
+              DatadogAPIClient::V1::WidgetFormula.new({
+                formula: "query1",
+              }),
+            ],
+            sort: DatadogAPIClient::V1::WidgetSortBy.new({
+              count: 10,
+              order_by: [
+                DatadogAPIClient::V1::WidgetGroupSort.new({
+                  type: DatadogAPIClient::V1::GroupType::GROUP,
+                  name: "service",
+                  order: DatadogAPIClient::V1::WidgetSort::ASCENDING,
+                }),
+              ],
+            }),
+            response_format: DatadogAPIClient::V1::FormulaAndFunctionResponseFormat::SCALAR,
+          }),
+        ],
+      }),
+    }),
+  ],
+  template_variables: [],
+  layout_type: DatadogAPIClient::V1::DashboardLayoutType::FREE,
+  is_read_only: false,
+  notify_list: [],
+})
+p api_instance.create_dashboard(body)

data/examples/v1/dashboards/CreateDashboard_3669695268.rb

@@ -34,12 +34,18 @@ body = DatadogAPIClient::V1::Dashboard.new({
                 conditional_formats: [],
                 cell_display_mode: DatadogAPIClient::V1::TableWidgetCellDisplayMode::BAR,
                 formula: "query1",
-                limit: DatadogAPIClient::V1::WidgetFormulaLimit.new({
-                  count: 50,
-                  order: DatadogAPIClient::V1::QuerySortOrder::DESC,
-                }),
               }),
             ],
+            sort: DatadogAPIClient::V1::WidgetSortBy.new({
+              count: 50,
+              order_by: [
+                DatadogAPIClient::V1::WidgetFormulaSort.new({
+                  type: DatadogAPIClient::V1::FormulaType::FORMULA,
+                  index: 0,
+                  order: DatadogAPIClient::V1::WidgetSort::DESCENDING,
+                }),
+              ],
+            }),
             response_format: DatadogAPIClient::V1::FormulaAndFunctionResponseFormat::SCALAR,
           }),
         ],

data/examples/v1/dashboards/CreateDashboard_915214113.rb

@@ -25,10 +25,6 @@ body = DatadogAPIClient::V1::Dashboard.new({
             formulas: [
               DatadogAPIClient::V1::WidgetFormula.new({
                 formula: "query1",
-                limit: DatadogAPIClient::V1::WidgetFormulaLimit.new({
-                  count: 250,
-                  order: DatadogAPIClient::V1::QuerySortOrder::DESC,
-                }),
               }),
             ],
             queries: [
@@ -56,6 +52,16 @@ body = DatadogAPIClient::V1::Dashboard.new({
                 ],
               }),
             ],
+            sort: DatadogAPIClient::V1::WidgetSortBy.new({
+              count: 250,
+              order_by: [
+                DatadogAPIClient::V1::WidgetFormulaSort.new({
+                  type: DatadogAPIClient::V1::FormulaType::FORMULA,
+                  index: 0,
+                  order: DatadogAPIClient::V1::WidgetSort::DESCENDING,
+                }),
+              ],
+            }),
             response_format: DatadogAPIClient::V1::FormulaAndFunctionResponseFormat::SCALAR,
           }),
         ],

data/examples/v1/monitors/UpdateMonitor.rb

@@ -9,6 +9,7 @@ MONITOR_NAME = ENV["MONITOR_NAME"]
 
 body = DatadogAPIClient::V1::MonitorUpdateRequest.new({
   name: "My monitor-updated",
+  priority: nil,
   options: DatadogAPIClient::V1::MonitorOptions.new({
     evaluation_delay: nil,
     new_group_delay: 600,

data/examples/v1/synthetics/CreateSyntheticsAPITest_1241981394.rb

@@ -72,6 +72,7 @@ body = DatadogAPIClient::V1::SyntheticsAPITest.new({
       files: [
         DatadogAPIClient::V1::SyntheticsTestRequestBodyFile.new({
           name: "file name",
+          original_file_name: "image.png",
           content: "file content",
           type: "file type",
         }),

data/examples/v1/synthetics/CreateSyntheticsAPITest_1279271422.rb

@@ -14,7 +14,7 @@ body = DatadogAPIClient::V1::SyntheticsAPITest.new({
       }),
     ],
     steps: [
-      DatadogAPIClient::V1::SyntheticsAPIStep.new({
+      DatadogAPIClient::V1::SyntheticsAPITestStep.new({
         allow_failure: true,
         assertions: [
           DatadogAPIClient::V1::SyntheticsAssertionTarget.new({
@@ -46,11 +46,16 @@ body = DatadogAPIClient::V1::SyntheticsAPITest.new({
           count: 5,
           interval: 1000,
         }),
-        subtype: DatadogAPIClient::V1::SyntheticsAPIStepSubtype::HTTP,
+        subtype: DatadogAPIClient::V1::SyntheticsAPITestStepSubtype::HTTP,
       }),
-      DatadogAPIClient::V1::SyntheticsAPIStep.new({
+      DatadogAPIClient::V1::SyntheticsAPIWaitStep.new({
+        name: "Wait",
+        subtype: DatadogAPIClient::V1::SyntheticsAPIWaitStepSubtype::WAIT,
+        value: 1,
+      }),
+      DatadogAPIClient::V1::SyntheticsAPITestStep.new({
         name: "GRPC CALL",
-        subtype: DatadogAPIClient::V1::SyntheticsAPIStepSubtype::GRPC,
+        subtype: DatadogAPIClient::V1::SyntheticsAPITestStepSubtype::GRPC,
         extracted_values: [],
         allow_failure: false,
         is_critical: true,

data/examples/v1/synthetics/CreateSyntheticsAPITest_1487281163.rb

@@ -27,6 +27,16 @@ body = DatadogAPIClient::V1::SyntheticsAPITest.new({
         }),
         type: DatadogAPIClient::V1::SyntheticsAssertionType::BODY,
       }),
+      DatadogAPIClient::V1::SyntheticsAssertionJSONPathTarget.new({
+        operator: DatadogAPIClient::V1::SyntheticsAssertionJSONPathOperator::VALIDATES_JSON_PATH,
+        target: DatadogAPIClient::V1::SyntheticsAssertionJSONPathTargetTarget.new({
+          elements_operator: "atLeastOneElementMatches",
+          json_path: "topKey",
+          operator: "isNot",
+          target_value: "0",
+        }),
+        type: DatadogAPIClient::V1::SyntheticsAssertionType::BODY,
+      }),
       DatadogAPIClient::V1::SyntheticsAssertionJSONSchemaTarget.new({
         operator: DatadogAPIClient::V1::SyntheticsAssertionJSONSchemaOperator::VALIDATES_JSON_SCHEMA,
         target: DatadogAPIClient::V1::SyntheticsAssertionJSONSchemaTargetTarget.new({
@@ -44,6 +54,11 @@ body = DatadogAPIClient::V1::SyntheticsAPITest.new({
         }),
         type: DatadogAPIClient::V1::SyntheticsAssertionType::BODY,
       }),
+      DatadogAPIClient::V1::SyntheticsAssertionBodyHashTarget.new({
+        operator: DatadogAPIClient::V1::SyntheticsAssertionBodyHashOperator::MD5,
+        target: "a",
+        type: DatadogAPIClient::V1::SyntheticsAssertionBodyHashType::BODY_HASH,
+      }),
     ],
     config_variables: [
       DatadogAPIClient::V1::SyntheticsConfigVariable.new({

data/examples/v1/synthetics/CreateSyntheticsAPITest_1987645492.rb

@@ -0,0 +1,134 @@
+# Create an API HTTP test has bodyHash filled out
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V1::SyntheticsAPI.new
+
+body = DatadogAPIClient::V1::SyntheticsAPITest.new({
+  config: DatadogAPIClient::V1::SyntheticsAPITestConfig.new({
+    assertions: [
+      DatadogAPIClient::V1::SyntheticsAssertionTarget.new({
+        operator: DatadogAPIClient::V1::SyntheticsAssertionOperator::IS,
+        property: "{{ PROPERTY }}",
+        target: "text/html",
+        type: DatadogAPIClient::V1::SyntheticsAssertionType::HEADER,
+      }),
+      DatadogAPIClient::V1::SyntheticsAssertionTarget.new({
+        operator: DatadogAPIClient::V1::SyntheticsAssertionOperator::LESS_THAN,
+        target: 2000,
+        type: DatadogAPIClient::V1::SyntheticsAssertionType::RESPONSE_TIME,
+        timings_scope: DatadogAPIClient::V1::SyntheticsAssertionTimingsScope::WITHOUT_DNS,
+      }),
+      DatadogAPIClient::V1::SyntheticsAssertionJSONPathTarget.new({
+        operator: DatadogAPIClient::V1::SyntheticsAssertionJSONPathOperator::VALIDATES_JSON_PATH,
+        target: DatadogAPIClient::V1::SyntheticsAssertionJSONPathTargetTarget.new({
+          json_path: "topKey",
+          operator: "isNot",
+          target_value: "0",
+        }),
+        type: DatadogAPIClient::V1::SyntheticsAssertionType::BODY,
+      }),
+      DatadogAPIClient::V1::SyntheticsAssertionJSONPathTarget.new({
+        operator: DatadogAPIClient::V1::SyntheticsAssertionJSONPathOperator::VALIDATES_JSON_PATH,
+        target: DatadogAPIClient::V1::SyntheticsAssertionJSONPathTargetTarget.new({
+          elements_operator: "atLeastOneElementMatches",
+          json_path: "topKey",
+          operator: "isNot",
+          target_value: "0",
+        }),
+        type: DatadogAPIClient::V1::SyntheticsAssertionType::BODY,
+      }),
+      DatadogAPIClient::V1::SyntheticsAssertionJSONSchemaTarget.new({
+        operator: DatadogAPIClient::V1::SyntheticsAssertionJSONSchemaOperator::VALIDATES_JSON_SCHEMA,
+        target: DatadogAPIClient::V1::SyntheticsAssertionJSONSchemaTargetTarget.new({
+          meta_schema: DatadogAPIClient::V1::SyntheticsAssertionJSONSchemaMetaSchema::DRAFT_07,
+          json_schema: '{"type": "object", "properties":{"slideshow":{"type":"object"}}}',
+        }),
+        type: DatadogAPIClient::V1::SyntheticsAssertionType::BODY,
+      }),
+      DatadogAPIClient::V1::SyntheticsAssertionXPathTarget.new({
+        operator: DatadogAPIClient::V1::SyntheticsAssertionXPathOperator::VALIDATES_X_PATH,
+        target: DatadogAPIClient::V1::SyntheticsAssertionXPathTargetTarget.new({
+          x_path: "target-xpath",
+          target_value: "0",
+          operator: "contains",
+        }),
+        type: DatadogAPIClient::V1::SyntheticsAssertionType::BODY,
+      }),
+      DatadogAPIClient::V1::SyntheticsAssertionBodyHashTarget.new({
+        operator: DatadogAPIClient::V1::SyntheticsAssertionBodyHashOperator::MD5,
+        target: "a",
+        type: DatadogAPIClient::V1::SyntheticsAssertionBodyHashType::BODY_HASH,
+      }),
+    ],
+    config_variables: [
+      DatadogAPIClient::V1::SyntheticsConfigVariable.new({
+        example: "content-type",
+        name: "PROPERTY",
+        pattern: "content-type",
+        type: DatadogAPIClient::V1::SyntheticsConfigVariableType::TEXT,
+      }),
+    ],
+    variables_from_script: 'dd.variable.set("FOO", "foo")',
+    request: DatadogAPIClient::V1::SyntheticsTestRequest.new({
+      certificate: DatadogAPIClient::V1::SyntheticsTestRequestCertificate.new({
+        cert: DatadogAPIClient::V1::SyntheticsTestRequestCertificateItem.new({
+          content: "cert-content",
+          filename: "cert-filename",
+          updated_at: "2020-10-16T09:23:24.857Z",
+        }),
+        key: DatadogAPIClient::V1::SyntheticsTestRequestCertificateItem.new({
+          content: "key-content",
+          filename: "key-filename",
+          updated_at: "2020-10-16T09:23:24.857Z",
+        }),
+      }),
+      headers: {
+        unique: "examplesynthetic",
+      },
+      method: "GET",
+      timeout: 10,
+      url: "https://datadoghq.com",
+      proxy: DatadogAPIClient::V1::SyntheticsTestRequestProxy.new({
+        url: "https://datadoghq.com",
+        headers: {},
+      }),
+      basic_auth: DatadogAPIClient::V1::SyntheticsBasicAuthOauthClient.new({
+        access_token_url: "https://datadog-token.com",
+        audience: "audience",
+        client_id: "client-id",
+        client_secret: "client-secret",
+        resource: "resource",
+        scope: "yoyo",
+        token_api_authentication: DatadogAPIClient::V1::SyntheticsBasicAuthOauthTokenApiAuthentication::HEADER,
+        type: DatadogAPIClient::V1::SyntheticsBasicAuthOauthClientType::OAUTH_CLIENT,
+      }),
+      persist_cookies: true,
+    }),
+  }),
+  locations: [
+    "aws:us-east-2",
+  ],
+  message: "BDD test payload: synthetics_api_http_test_payload.json",
+  name: "Example-Synthetic",
+  options: DatadogAPIClient::V1::SyntheticsTestOptions.new({
+    accept_self_signed: false,
+    allow_insecure: true,
+    follow_redirects: true,
+    min_failure_duration: 10,
+    min_location_failed: 1,
+    monitor_name: "Example-Synthetic",
+    monitor_priority: 5,
+    _retry: DatadogAPIClient::V1::SyntheticsTestOptionsRetry.new({
+      count: 3,
+      interval: 10,
+    }),
+    tick_every: 60,
+    http_version: DatadogAPIClient::V1::SyntheticsTestOptionsHTTPVersion::HTTP2,
+  }),
+  subtype: DatadogAPIClient::V1::SyntheticsTestDetailsSubType::HTTP,
+  tags: [
+    "testing:api",
+  ],
+  type: DatadogAPIClient::V1::SyntheticsAPITestType::API,
+})
+p api_instance.create_synthetics_api_test(body)

data/examples/v2/api-management/ListAPIs.rb

@@ -0,0 +1,8 @@
+# List APIs returns "OK" response
+
+require "datadog_api_client"
+DatadogAPIClient.configure do |config|
+  config.unstable_operations["v2.list_apis".to_sym] = true
+end
+api_instance = DatadogAPIClient::V2::APIManagementAPI.new
+p api_instance.list_apis()

data/examples/v2/csm-threats/CreateCSMThreatsAgentRule.rb

@@ -9,6 +9,9 @@ body = DatadogAPIClient::V2::CloudWorkloadSecurityAgentRuleCreateRequest.new({
       description: "My Agent rule",
       enabled: true,
       expression: 'exec.file.name == "sh"',
+      filters: [
+        'os == "linux"',
+      ],
       name: "examplecsmthreat",
     }),
     type: DatadogAPIClient::V2::CloudWorkloadSecurityAgentRuleType::AGENT_RULE,

data/examples/v2/csm-threats/UpdateCloudWorkloadSecurityAgentRule.rb

@@ -14,6 +14,7 @@ body = DatadogAPIClient::V2::CloudWorkloadSecurityAgentRuleUpdateRequest.new({
       expression: 'exec.file.name == "sh"',
     }),
     type: DatadogAPIClient::V2::CloudWorkloadSecurityAgentRuleType::AGENT_RULE,
+    id: AGENT_RULE_DATA_ID,
   }),
 })
 p api_instance.update_cloud_workload_security_agent_rule(AGENT_RULE_DATA_ID, body)

data/examples/v2/organizations/GetOrgConfig.rb

@@ -0,0 +1,5 @@
+# Get a specific Org Config value returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::OrganizationsAPI.new
+p api_instance.get_org_config("custom_roles")

data/examples/v2/organizations/ListOrgConfigs.rb

@@ -0,0 +1,5 @@
+# List Org Configs returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::OrganizationsAPI.new
+p api_instance.list_org_configs()

data/examples/v2/organizations/UpdateOrgConfig.rb

@@ -0,0 +1,14 @@
+# Update a specific Org Config returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::OrganizationsAPI.new
+
+body = DatadogAPIClient::V2::OrgConfigWriteRequest.new({
+  data: DatadogAPIClient::V2::OrgConfigWrite.new({
+    attributes: DatadogAPIClient::V2::OrgConfigWriteAttributes.new({
+      value: "UTC",
+    }),
+    type: DatadogAPIClient::V2::OrgConfigType::ORG_CONFIGS,
+  }),
+})
+p api_instance.update_org_config("monitor_timezone", body)

data/examples/v2/security-monitoring/TestExistingSecurityMonitoringRule.rb

@@ -0,0 +1,21 @@
+# Test an existing rule returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::SecurityMonitoringAPI.new
+
+body = DatadogAPIClient::V2::SecurityMonitoringRuleTestRequest.new({
+  rule_query_payloads: [
+    DatadogAPIClient::V2::SecurityMonitoringRuleQueryPayload.new({
+      expected_result: true,
+      index: 0,
+      payload: DatadogAPIClient::V2::SecurityMonitoringRuleQueryPayloadData.new({
+        ddsource: "nginx",
+        ddtags: "env:staging,version:5.1",
+        hostname: "i-012345678",
+        message: "2019-11-19T14:37:58,995 INFO [process.name][20081] Hello World",
+        service: "payment",
+      }),
+    }),
+  ],
+})
+p api_instance.test_existing_security_monitoring_rule("rule_id", body)

data/examples/v2/security-monitoring/TestSecurityMonitoringRule.rb

@@ -0,0 +1,58 @@
+# Test a rule returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::SecurityMonitoringAPI.new
+
+body = DatadogAPIClient::V2::SecurityMonitoringRuleTestRequest.new({
+  rule: DatadogAPIClient::V2::SecurityMonitoringStandardRuleTestPayload.new({
+    cases: [
+      DatadogAPIClient::V2::SecurityMonitoringRuleCaseCreate.new({
+        name: "",
+        status: DatadogAPIClient::V2::SecurityMonitoringRuleSeverity::INFO,
+        notifications: [],
+        condition: "a > 0",
+      }),
+    ],
+    has_extended_title: true,
+    is_enabled: true,
+    message: "My security monitoring rule message.",
+    name: "My security monitoring rule.",
+    options: DatadogAPIClient::V2::SecurityMonitoringRuleOptions.new({
+      decrease_criticality_based_on_env: false,
+      detection_method: DatadogAPIClient::V2::SecurityMonitoringRuleDetectionMethod::THRESHOLD,
+      evaluation_window: DatadogAPIClient::V2::SecurityMonitoringRuleEvaluationWindow::ZERO_MINUTES,
+      keep_alive: DatadogAPIClient::V2::SecurityMonitoringRuleKeepAlive::ZERO_MINUTES,
+      max_signal_duration: DatadogAPIClient::V2::SecurityMonitoringRuleMaxSignalDuration::ZERO_MINUTES,
+    }),
+    queries: [
+      DatadogAPIClient::V2::SecurityMonitoringStandardRuleQuery.new({
+        query: "source:source_here",
+        group_by_fields: [
+          "@userIdentity.assumed_role",
+        ],
+        distinct_fields: [],
+        aggregation: DatadogAPIClient::V2::SecurityMonitoringRuleQueryAggregation::COUNT,
+        name: "",
+      }),
+    ],
+    tags: [
+      "env:prod",
+      "team:security",
+    ],
+    type: DatadogAPIClient::V2::SecurityMonitoringRuleTypeTest::LOG_DETECTION,
+  }),
+  rule_query_payloads: [
+    DatadogAPIClient::V2::SecurityMonitoringRuleQueryPayload.new({
+      expected_result: true,
+      index: 0,
+      payload: DatadogAPIClient::V2::SecurityMonitoringRuleQueryPayloadData.new({
+        ddsource: "source_here",
+        ddtags: "env:staging,version:5.1",
+        hostname: "i-012345678",
+        message: "2019-11-19T14:37:58,995 INFO [process.name][20081] Hello World",
+        service: "payment",
+      }),
+    }),
+  ],
+})
+p api_instance.test_security_monitoring_rule(body)

data/examples/v2/security-monitoring/ValidateSecurityMonitoringRule.rb

@@ -3,7 +3,7 @@
 require "datadog_api_client"
 api_instance = DatadogAPIClient::V2::SecurityMonitoringAPI.new
 
-body = DatadogAPIClient::V2::SecurityMonitoringStandardRuleCreatePayload.new({
+body = DatadogAPIClient::V2::SecurityMonitoringStandardRulePayload.new({
   cases: [
     DatadogAPIClient::V2::SecurityMonitoringRuleCaseCreate.new({
       name: "",

data/lib/datadog_api_client/configuration.rb

@@ -192,6 +192,7 @@ module DatadogAPIClient
             "v2.create_open_api": false,
             "v2.delete_open_api": false,
             "v2.get_open_api": false,
+            "v2.list_apis": false,
             "v2.update_open_api": false,
             "v2.get_active_billing_dimensions": false,
             "v2.get_monthly_cost_attribution": false,