Generate Log Restriction Query API Spec

examples/v2_logs-restriction-queries_AddRoleToRestrictionQuery.rs

@@ -0,0 +1,26 @@
+// 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() {
+    let body = RelationshipToRole::new().data(
+        RelationshipToRoleData::new()
+            .id("3653d3c6-0c75-11ea-ad28-fb5701eabc7d".to_string())
+            .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_id".to_string(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_logs-restriction-queries_CreateRestrictionQuery.rs

@@ -0,0 +1,28 @@
+// 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()
+                    .restriction_query("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_DeleteRestrictionQuery.rs

@@ -0,0 +1,18 @@
+// 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() {
+    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_id".to_string())
+        .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 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() {
+    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_id".to_string())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_logs-restriction-queries_GetRoleRestrictionQuery.rs

@@ -0,0 +1,16 @@
+// 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() {
+    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_id".to_string()).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_logs-restriction-queries_ListRestrictionQueries.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_ListRestrictionQueryRoles.rs

@@ -0,0 +1,22 @@
+// 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() {
+    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_id".to_string(),
+            ListRestrictionQueryRolesOptionalParams::default(),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_logs-restriction-queries_ListUserRestrictionQueries.rs

@@ -0,0 +1,18 @@
+// 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() {
+    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_id".to_string())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_logs-restriction-queries_RemoveRoleFromRestrictionQuery.rs

@@ -0,0 +1,26 @@
+// 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() {
+    let body = RelationshipToRole::new().data(
+        RelationshipToRoleData::new()
+            .id("3653d3c6-0c75-11ea-ad28-fb5701eabc7d".to_string())
+            .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_id".to_string(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_logs-restriction-queries_UpdateRestrictionQuery.rs

@@ -0,0 +1,30 @@
+// Update 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::RestrictionQueryUpdateAttributes;
+use datadog_api_client::datadogV2::model::RestrictionQueryUpdateData;
+use datadog_api_client::datadogV2::model::RestrictionQueryUpdatePayload;
+
+#[tokio::main]
+async fn main() {
+    let body = RestrictionQueryUpdatePayload::new().data(
+        RestrictionQueryUpdateData::new()
+            .attributes(
+                RestrictionQueryUpdateAttributes::new()
+                    .restriction_query("env:sandbox".to_string()),
+            )
+            .type_(LogsRestrictionQueriesType::LOGS_RESTRICTION_QUERIES),
+    );
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.UpdateRestrictionQuery", true);
+    let api = LogsRestrictionQueriesAPI::with_config(configuration);
+    let resp = api
+        .update_restriction_query("restriction_query_id".to_string(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

src/datadog/configuration.rs

@@ -210,6 +210,16 @@ impl Default for Configuration {
             ("v2.update_incident_notification_template".to_owned(), false),
             ("v2.update_incident_todo".to_owned(), false),
             ("v2.update_incident_type".to_owned(), false),
+            ("v2.add_role_to_restriction_query".to_owned(), false),
+            ("v2.create_restriction_query".to_owned(), false),
+            ("v2.delete_restriction_query".to_owned(), false),
+            ("v2.get_restriction_query".to_owned(), false),
+            ("v2.get_role_restriction_query".to_owned(), false),
+            ("v2.list_restriction_queries".to_owned(), false),
+            ("v2.list_restriction_query_roles".to_owned(), false),
+            ("v2.list_user_restriction_queries".to_owned(), false),
+            ("v2.remove_role_from_restriction_query".to_owned(), false),
+            ("v2.update_restriction_query".to_owned(), false),
             ("v2.create_monitor_user_template".to_owned(), false),
             ("v2.delete_monitor_user_template".to_owned(), false),
             ("v2.get_monitor_user_template".to_owned(), false),