Generate API Spec for Log Restriction Queries

examples/v2_logs-restriction-queries_AddRoleToRestrictionQuery.rs

@@ -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_CreateRestrictionQuery.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_DeleteRestrictionQuery.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_GetRestrictionQuery.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_GetRoleRestrictionQuery.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_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,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_ListUserRestrictionQueries.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_RemoveRoleFromRestrictionQuery.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());
+    }
+}

examples/v2_logs-restriction-queries_ReplaceRestrictionQuery.rs

@@ -0,0 +1,31 @@
+// Replace 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() {
+    // there is a valid "restriction_query" in the system
+    let restriction_query_data_id = std::env::var("RESTRICTION_QUERY_DATA_ID").unwrap();
+    let body = RestrictionQueryUpdatePayload::new().data(
+        RestrictionQueryUpdateData::new()
+            .attributes(RestrictionQueryUpdateAttributes::new(
+                "env:staging".to_string(),
+            ))
+            .type_(LogsRestrictionQueriesType::LOGS_RESTRICTION_QUERIES),
+    );
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.ReplaceRestrictionQuery", true);
+    let api = LogsRestrictionQueriesAPI::with_config(configuration);
+    let resp = api
+        .replace_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_UpdateRestrictionQuery.rs

@@ -0,0 +1,31 @@
+// 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() {
+    // there is a valid "restriction_query" in the system
+    let restriction_query_data_id = std::env::var("RESTRICTION_QUERY_DATA_ID").unwrap();
+    let body = RestrictionQueryUpdatePayload::new().data(
+        RestrictionQueryUpdateData::new()
+            .attributes(RestrictionQueryUpdateAttributes::new(
+                "env:production".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_data_id.clone(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_teams_AddTeamHierarchyLink.rs

@@ -0,0 +1,40 @@
+// Create a team hierarchy link returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_teams::TeamsAPI;
+use datadog_api_client::datadogV2::model::TeamHierarchyLinkCreate;
+use datadog_api_client::datadogV2::model::TeamHierarchyLinkCreateRelationships;
+use datadog_api_client::datadogV2::model::TeamHierarchyLinkCreateRequest;
+use datadog_api_client::datadogV2::model::TeamHierarchyLinkCreateTeam;
+use datadog_api_client::datadogV2::model::TeamHierarchyLinkCreateTeamRelationship;
+use datadog_api_client::datadogV2::model::TeamHierarchyLinkType;
+use datadog_api_client::datadogV2::model::TeamType;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "dd_team" in the system
+    let dd_team_data_id = std::env::var("DD_TEAM_DATA_ID").unwrap();
+
+    // there is a valid "dd_team_2" in the system
+    let dd_team_2_data_id = std::env::var("DD_TEAM_2_DATA_ID").unwrap();
+    let body = TeamHierarchyLinkCreateRequest::new(TeamHierarchyLinkCreate::new(
+        TeamHierarchyLinkCreateRelationships::new(
+            TeamHierarchyLinkCreateTeamRelationship::new(TeamHierarchyLinkCreateTeam::new(
+                dd_team_data_id.clone(),
+                TeamType::TEAM,
+            )),
+            TeamHierarchyLinkCreateTeamRelationship::new(TeamHierarchyLinkCreateTeam::new(
+                dd_team_2_data_id.clone(),
+                TeamType::TEAM,
+            )),
+        ),
+        TeamHierarchyLinkType::TEAM_HIERARCHY_LINKS,
+    ));
+    let configuration = datadog::Configuration::new();
+    let api = TeamsAPI::with_config(configuration);
+    let resp = api.add_team_hierarchy_link(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_teams_GetTeamHierarchyLink.rs

@@ -0,0 +1,19 @@
+// Get a team hierarchy link returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_teams::TeamsAPI;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "team_hierarchy_link" in the system
+    let team_hierarchy_link_data_id = std::env::var("TEAM_HIERARCHY_LINK_DATA_ID").unwrap();
+    let configuration = datadog::Configuration::new();
+    let api = TeamsAPI::with_config(configuration);
+    let resp = api
+        .get_team_hierarchy_link(team_hierarchy_link_data_id.clone())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_teams_ListTeamHierarchyLinks.rs

@@ -0,0 +1,31 @@
+// Get team hierarchy links returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_teams::ListTeamHierarchyLinksOptionalParams;
+use datadog_api_client::datadogV2::api_teams::TeamsAPI;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "team_hierarchy_link" in the system
+    let team_hierarchy_link_data_relationships_parent_team_data_id =
+        std::env::var("TEAM_HIERARCHY_LINK_DATA_RELATIONSHIPS_PARENT_TEAM_DATA_ID").unwrap();
+    let team_hierarchy_link_data_relationships_sub_team_data_id =
+        std::env::var("TEAM_HIERARCHY_LINK_DATA_RELATIONSHIPS_SUB_TEAM_DATA_ID").unwrap();
+    let configuration = datadog::Configuration::new();
+    let api = TeamsAPI::with_config(configuration);
+    let resp = api
+        .list_team_hierarchy_links(
+            ListTeamHierarchyLinksOptionalParams::default()
+                .filter_parent_team(
+                    team_hierarchy_link_data_relationships_parent_team_data_id.clone(),
+                )
+                .filter_sub_team(team_hierarchy_link_data_relationships_sub_team_data_id.clone())
+                .page_number(0)
+                .page_size(100),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_teams_ListTeamHierarchyLinks_3360757486.rs

@@ -0,0 +1,22 @@
+// Get team hierarchy links returns "OK" response with pagination
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_teams::ListTeamHierarchyLinksOptionalParams;
+use datadog_api_client::datadogV2::api_teams::TeamsAPI;
+use futures_util::pin_mut;
+use futures_util::stream::StreamExt;
+
+#[tokio::main]
+async fn main() {
+    let configuration = datadog::Configuration::new();
+    let api = TeamsAPI::with_config(configuration);
+    let response = api
+        .list_team_hierarchy_links_with_pagination(ListTeamHierarchyLinksOptionalParams::default());
+    pin_mut!(response);
+    while let Some(resp) = response.next().await {
+        if let Ok(value) = resp {
+            println!("{:#?}", value);
+        } else {
+            println!("{:#?}", resp.unwrap_err());
+        }
+    }
+}