Add Org Groups API specification

examples/v2_org-groups_BulkUpdateOrgGroupMemberships.rs

@@ -0,0 +1,43 @@
+// Bulk update org group memberships returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_org_groups::OrgGroupsAPI;
+use datadog_api_client::datadogV2::model::GlobalOrgIdentifier;
+use datadog_api_client::datadogV2::model::OrgGroupMembershipBulkUpdateAttributes;
+use datadog_api_client::datadogV2::model::OrgGroupMembershipBulkUpdateData;
+use datadog_api_client::datadogV2::model::OrgGroupMembershipBulkUpdateRelationships;
+use datadog_api_client::datadogV2::model::OrgGroupMembershipBulkUpdateRequest;
+use datadog_api_client::datadogV2::model::OrgGroupMembershipBulkUpdateType;
+use datadog_api_client::datadogV2::model::OrgGroupRelationshipToOne;
+use datadog_api_client::datadogV2::model::OrgGroupRelationshipToOneData;
+use datadog_api_client::datadogV2::model::OrgGroupType;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() {
+    let body = OrgGroupMembershipBulkUpdateRequest::new(OrgGroupMembershipBulkUpdateData::new(
+        OrgGroupMembershipBulkUpdateAttributes::new(vec![GlobalOrgIdentifier::new(
+            "datadoghq.com".to_string(),
+            Uuid::parse_str("c3d4e5f6-a7b8-9012-cdef-012345678901").expect("invalid UUID"),
+        )]),
+        OrgGroupMembershipBulkUpdateRelationships::new(
+            OrgGroupRelationshipToOne::new(OrgGroupRelationshipToOneData::new(
+                Uuid::parse_str("a1b2c3d4-e5f6-7890-abcd-ef0123456789").expect("invalid UUID"),
+                OrgGroupType::ORG_GROUPS,
+            )),
+            OrgGroupRelationshipToOne::new(OrgGroupRelationshipToOneData::new(
+                Uuid::parse_str("a1b2c3d4-e5f6-7890-abcd-ef0123456789").expect("invalid UUID"),
+                OrgGroupType::ORG_GROUPS,
+            )),
+        ),
+        OrgGroupMembershipBulkUpdateType::ORG_GROUP_MEMBERSHIP_BULK_UPDATES,
+    ));
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.BulkUpdateOrgGroupMemberships", true);
+    let api = OrgGroupsAPI::with_config(configuration);
+    let resp = api.bulk_update_org_group_memberships(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_org-groups_CreateOrgGroup.rs

@@ -0,0 +1,24 @@
+// Create an org group returns "Created" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_org_groups::OrgGroupsAPI;
+use datadog_api_client::datadogV2::model::OrgGroupCreateAttributes;
+use datadog_api_client::datadogV2::model::OrgGroupCreateData;
+use datadog_api_client::datadogV2::model::OrgGroupCreateRequest;
+use datadog_api_client::datadogV2::model::OrgGroupType;
+
+#[tokio::main]
+async fn main() {
+    let body = OrgGroupCreateRequest::new(OrgGroupCreateData::new(
+        OrgGroupCreateAttributes::new("My Org Group".to_string()),
+        OrgGroupType::ORG_GROUPS,
+    ));
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.CreateOrgGroup", true);
+    let api = OrgGroupsAPI::with_config(configuration);
+    let resp = api.create_org_group(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_org-groups_CreateOrgGroupPolicy.rs

@@ -0,0 +1,40 @@
+// Create an org group policy returns "Created" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_org_groups::OrgGroupsAPI;
+use datadog_api_client::datadogV2::model::OrgGroupPolicyCreateAttributes;
+use datadog_api_client::datadogV2::model::OrgGroupPolicyCreateData;
+use datadog_api_client::datadogV2::model::OrgGroupPolicyCreateRelationships;
+use datadog_api_client::datadogV2::model::OrgGroupPolicyCreateRequest;
+use datadog_api_client::datadogV2::model::OrgGroupPolicyType;
+use datadog_api_client::datadogV2::model::OrgGroupRelationshipToOne;
+use datadog_api_client::datadogV2::model::OrgGroupRelationshipToOneData;
+use datadog_api_client::datadogV2::model::OrgGroupType;
+use serde_json::Value;
+use std::collections::BTreeMap;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() {
+    let body = OrgGroupPolicyCreateRequest::new(OrgGroupPolicyCreateData::new(
+        OrgGroupPolicyCreateAttributes::new(
+            BTreeMap::from([("value".to_string(), Value::from("UTC"))]),
+            "monitor_timezone".to_string(),
+        ),
+        OrgGroupPolicyCreateRelationships::new(OrgGroupRelationshipToOne::new(
+            OrgGroupRelationshipToOneData::new(
+                Uuid::parse_str("a1b2c3d4-e5f6-7890-abcd-ef0123456789").expect("invalid UUID"),
+                OrgGroupType::ORG_GROUPS,
+            ),
+        )),
+        OrgGroupPolicyType::ORG_GROUP_POLICIES,
+    ));
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.CreateOrgGroupPolicy", true);
+    let api = OrgGroupsAPI::with_config(configuration);
+    let resp = api.create_org_group_policy(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_org-groups_CreateOrgGroupPolicyOverride.rs

@@ -0,0 +1,45 @@
+// Create an org group policy override returns "Created" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_org_groups::OrgGroupsAPI;
+use datadog_api_client::datadogV2::model::OrgGroupPolicyOverrideCreateAttributes;
+use datadog_api_client::datadogV2::model::OrgGroupPolicyOverrideCreateData;
+use datadog_api_client::datadogV2::model::OrgGroupPolicyOverrideCreateRelationships;
+use datadog_api_client::datadogV2::model::OrgGroupPolicyOverrideCreateRequest;
+use datadog_api_client::datadogV2::model::OrgGroupPolicyOverrideType;
+use datadog_api_client::datadogV2::model::OrgGroupPolicyRelationshipToOne;
+use datadog_api_client::datadogV2::model::OrgGroupPolicyRelationshipToOneData;
+use datadog_api_client::datadogV2::model::OrgGroupPolicyType;
+use datadog_api_client::datadogV2::model::OrgGroupRelationshipToOne;
+use datadog_api_client::datadogV2::model::OrgGroupRelationshipToOneData;
+use datadog_api_client::datadogV2::model::OrgGroupType;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() {
+    let body = OrgGroupPolicyOverrideCreateRequest::new(OrgGroupPolicyOverrideCreateData::new(
+        OrgGroupPolicyOverrideCreateAttributes::new(
+            "datadoghq.com".to_string(),
+            Uuid::parse_str("c3d4e5f6-a7b8-9012-cdef-012345678901").expect("invalid UUID"),
+        ),
+        OrgGroupPolicyOverrideCreateRelationships::new(
+            OrgGroupRelationshipToOne::new(OrgGroupRelationshipToOneData::new(
+                Uuid::parse_str("a1b2c3d4-e5f6-7890-abcd-ef0123456789").expect("invalid UUID"),
+                OrgGroupType::ORG_GROUPS,
+            )),
+            OrgGroupPolicyRelationshipToOne::new(OrgGroupPolicyRelationshipToOneData::new(
+                Uuid::parse_str("1a2b3c4d-5e6f-7890-abcd-ef0123456789").expect("invalid UUID"),
+                OrgGroupPolicyType::ORG_GROUP_POLICIES,
+            )),
+        ),
+        OrgGroupPolicyOverrideType::ORG_GROUP_POLICY_OVERRIDES,
+    ));
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.CreateOrgGroupPolicyOverride", true);
+    let api = OrgGroupsAPI::with_config(configuration);
+    let resp = api.create_org_group_policy_override(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_org-groups_DeleteOrgGroup.rs

@@ -0,0 +1,21 @@
+// Delete an org group returns "No Content" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_org_groups::OrgGroupsAPI;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.DeleteOrgGroup", true);
+    let api = OrgGroupsAPI::with_config(configuration);
+    let resp = api
+        .delete_org_group(
+            Uuid::parse_str("a1b2c3d4-e5f6-7890-abcd-ef0123456789").expect("invalid UUID"),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_org-groups_DeleteOrgGroupPolicy.rs

@@ -0,0 +1,21 @@
+// Delete an org group policy returns "No Content" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_org_groups::OrgGroupsAPI;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.DeleteOrgGroupPolicy", true);
+    let api = OrgGroupsAPI::with_config(configuration);
+    let resp = api
+        .delete_org_group_policy(
+            Uuid::parse_str("1a2b3c4d-5e6f-7890-abcd-ef0123456789").expect("invalid UUID"),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_org-groups_DeleteOrgGroupPolicyOverride.rs

@@ -0,0 +1,21 @@
+// Delete an org group policy override returns "No Content" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_org_groups::OrgGroupsAPI;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.DeleteOrgGroupPolicyOverride", true);
+    let api = OrgGroupsAPI::with_config(configuration);
+    let resp = api
+        .delete_org_group_policy_override(
+            Uuid::parse_str("9f8e7d6c-5b4a-3210-fedc-ba0987654321").expect("invalid UUID"),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_org-groups_GetOrgGroup.rs

@@ -0,0 +1,21 @@
+// Get an org group returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_org_groups::OrgGroupsAPI;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.GetOrgGroup", true);
+    let api = OrgGroupsAPI::with_config(configuration);
+    let resp = api
+        .get_org_group(
+            Uuid::parse_str("a1b2c3d4-e5f6-7890-abcd-ef0123456789").expect("invalid UUID"),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_org-groups_GetOrgGroupMembership.rs

@@ -0,0 +1,21 @@
+// Get an org group membership returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_org_groups::OrgGroupsAPI;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.GetOrgGroupMembership", true);
+    let api = OrgGroupsAPI::with_config(configuration);
+    let resp = api
+        .get_org_group_membership(
+            Uuid::parse_str("f1e2d3c4-b5a6-7890-1234-567890abcdef").expect("invalid UUID"),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_org-groups_ListOrgGroupMemberships.rs

@@ -0,0 +1,19 @@
+// List org group memberships returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_org_groups::ListOrgGroupMembershipsOptionalParams;
+use datadog_api_client::datadogV2::api_org_groups::OrgGroupsAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.ListOrgGroupMemberships", true);
+    let api = OrgGroupsAPI::with_config(configuration);
+    let resp = api
+        .list_org_group_memberships(ListOrgGroupMembershipsOptionalParams::default())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_org-groups_ListOrgGroupPolicies.rs

@@ -0,0 +1,23 @@
+// List org group policies returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_org_groups::ListOrgGroupPoliciesOptionalParams;
+use datadog_api_client::datadogV2::api_org_groups::OrgGroupsAPI;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.ListOrgGroupPolicies", true);
+    let api = OrgGroupsAPI::with_config(configuration);
+    let resp = api
+        .list_org_group_policies(
+            Uuid::parse_str("a1b2c3d4-e5f6-7890-abcd-ef0123456789").expect("invalid UUID"),
+            ListOrgGroupPoliciesOptionalParams::default(),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_org-groups_ListOrgGroupPolicyConfigs.rs

@@ -0,0 +1,16 @@
+// List org group policy configs returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_org_groups::OrgGroupsAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.ListOrgGroupPolicyConfigs", true);
+    let api = OrgGroupsAPI::with_config(configuration);
+    let resp = api.list_org_group_policy_configs().await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_org-groups_ListOrgGroupPolicyOverrides.rs

@@ -0,0 +1,23 @@
+// List org group policy overrides returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_org_groups::ListOrgGroupPolicyOverridesOptionalParams;
+use datadog_api_client::datadogV2::api_org_groups::OrgGroupsAPI;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.ListOrgGroupPolicyOverrides", true);
+    let api = OrgGroupsAPI::with_config(configuration);
+    let resp = api
+        .list_org_group_policy_overrides(
+            Uuid::parse_str("a1b2c3d4-e5f6-7890-abcd-ef0123456789").expect("invalid UUID"),
+            ListOrgGroupPolicyOverridesOptionalParams::default(),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_org-groups_ListOrgGroups.rs

@@ -0,0 +1,19 @@
+// List org groups returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_org_groups::ListOrgGroupsOptionalParams;
+use datadog_api_client::datadogV2::api_org_groups::OrgGroupsAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.ListOrgGroups", true);
+    let api = OrgGroupsAPI::with_config(configuration);
+    let resp = api
+        .list_org_groups(ListOrgGroupsOptionalParams::default())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}