Regenerate client from commit 87db0c7 of spec repo

Author: ci.datadog-api-spec

.generator/schemas/v2/openapi.yaml

@@ -0,0 +1,31 @@
+// Grant role to a restriction query returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_logs_restriction_queries::LogsRestrictionQueriesAPI;
+use datadog_api_client::datadogV2::model::RelationshipToRole;
+use datadog_api_client::datadogV2::model::RelationshipToRoleData;
+use datadog_api_client::datadogV2::model::RolesType;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "restriction_query" in the system
+    let restriction_query_data_id = std::env::var("RESTRICTION_QUERY_DATA_ID").unwrap();
+
+    // there is a valid "role" in the system
+    let role_data_id = std::env::var("ROLE_DATA_ID").unwrap();
+    let body = RelationshipToRole::new().data(
+        RelationshipToRoleData::new()
+            .id(role_data_id.clone())
+            .type_(RolesType::ROLES),
+    );
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.AddRoleToRestrictionQuery", true);
+    let api = LogsRestrictionQueriesAPI::with_config(configuration);
+    let resp = api
+        .add_role_to_restriction_query(restriction_query_data_id.clone(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_logs-restriction-queries_AddRoleToRestrictionQuery.rs

@@ -0,0 +1,27 @@
+// Create a restriction query returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_logs_restriction_queries::LogsRestrictionQueriesAPI;
+use datadog_api_client::datadogV2::model::LogsRestrictionQueriesType;
+use datadog_api_client::datadogV2::model::RestrictionQueryCreateAttributes;
+use datadog_api_client::datadogV2::model::RestrictionQueryCreateData;
+use datadog_api_client::datadogV2::model::RestrictionQueryCreatePayload;
+
+#[tokio::main]
+async fn main() {
+    let body = RestrictionQueryCreatePayload::new().data(
+        RestrictionQueryCreateData::new()
+            .attributes(RestrictionQueryCreateAttributes::new(
+                "env:sandbox".to_string(),
+            ))
+            .type_(LogsRestrictionQueriesType::LOGS_RESTRICTION_QUERIES),
+    );
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.CreateRestrictionQuery", true);
+    let api = LogsRestrictionQueriesAPI::with_config(configuration);
+    let resp = api.create_restriction_query(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_logs-restriction-queries_CreateRestrictionQuery.rs

@@ -0,0 +1,20 @@
+// Delete a restriction query returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_logs_restriction_queries::LogsRestrictionQueriesAPI;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "restriction_query" in the system
+    let restriction_query_data_id = std::env::var("RESTRICTION_QUERY_DATA_ID").unwrap();
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.DeleteRestrictionQuery", true);
+    let api = LogsRestrictionQueriesAPI::with_config(configuration);
+    let resp = api
+        .delete_restriction_query(restriction_query_data_id.clone())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_logs-restriction-queries_DeleteRestrictionQuery.rs

@@ -0,0 +1,20 @@
+// Get a restriction query returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_logs_restriction_queries::LogsRestrictionQueriesAPI;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "restriction_query" in the system
+    let restriction_query_data_id = std::env::var("RESTRICTION_QUERY_DATA_ID").unwrap();
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.GetRestrictionQuery", true);
+    let api = LogsRestrictionQueriesAPI::with_config(configuration);
+    let resp = api
+        .get_restriction_query(restriction_query_data_id.clone())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_logs-restriction-queries_GetRestrictionQuery.rs

@@ -0,0 +1,18 @@
+// Get restriction query for a given role returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_logs_restriction_queries::LogsRestrictionQueriesAPI;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "role" in the system
+    let role_data_id = std::env::var("ROLE_DATA_ID").unwrap();
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.GetRoleRestrictionQuery", true);
+    let api = LogsRestrictionQueriesAPI::with_config(configuration);
+    let resp = api.get_role_restriction_query(role_data_id.clone()).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_logs-restriction-queries_GetRoleRestrictionQuery.rs

@@ -0,0 +1,19 @@
+// List restriction queries returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_logs_restriction_queries::ListRestrictionQueriesOptionalParams;
+use datadog_api_client::datadogV2::api_logs_restriction_queries::LogsRestrictionQueriesAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.ListRestrictionQueries", true);
+    let api = LogsRestrictionQueriesAPI::with_config(configuration);
+    let resp = api
+        .list_restriction_queries(ListRestrictionQueriesOptionalParams::default())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_logs-restriction-queries_ListRestrictionQueries.rs

@@ -0,0 +1,24 @@
+// List roles for a restriction query returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_logs_restriction_queries::ListRestrictionQueryRolesOptionalParams;
+use datadog_api_client::datadogV2::api_logs_restriction_queries::LogsRestrictionQueriesAPI;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "restriction_query" in the system
+    let restriction_query_data_id = std::env::var("RESTRICTION_QUERY_DATA_ID").unwrap();
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.ListRestrictionQueryRoles", true);
+    let api = LogsRestrictionQueriesAPI::with_config(configuration);
+    let resp = api
+        .list_restriction_query_roles(
+            restriction_query_data_id.clone(),
+            ListRestrictionQueryRolesOptionalParams::default(),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_logs-restriction-queries_ListRestrictionQueryRoles.rs

@@ -0,0 +1,20 @@
+// Get all restriction queries for a given user returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_logs_restriction_queries::LogsRestrictionQueriesAPI;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "user" in the system
+    let user_data_id = std::env::var("USER_DATA_ID").unwrap();
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.ListUserRestrictionQueries", true);
+    let api = LogsRestrictionQueriesAPI::with_config(configuration);
+    let resp = api
+        .list_user_restriction_queries(user_data_id.clone())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_logs-restriction-queries_ListUserRestrictionQueries.rs

@@ -0,0 +1,31 @@
+// Revoke role from a restriction query returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_logs_restriction_queries::LogsRestrictionQueriesAPI;
+use datadog_api_client::datadogV2::model::RelationshipToRole;
+use datadog_api_client::datadogV2::model::RelationshipToRoleData;
+use datadog_api_client::datadogV2::model::RolesType;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "restriction_query" in the system
+    let restriction_query_data_id = std::env::var("RESTRICTION_QUERY_DATA_ID").unwrap();
+
+    // there is a valid "role" in the system
+    let role_data_id = std::env::var("ROLE_DATA_ID").unwrap();
+    let body = RelationshipToRole::new().data(
+        RelationshipToRoleData::new()
+            .id(role_data_id.clone())
+            .type_(RolesType::ROLES),
+    );
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.RemoveRoleFromRestrictionQuery", true);
+    let api = LogsRestrictionQueriesAPI::with_config(configuration);
+    let resp = api
+        .remove_role_from_restriction_query(restriction_query_data_id.clone(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}