Regenerate client from commit f883233 of spec repo

Author: ci.datadog-api-spec

.generator/schemas/v2/openapi.yaml

@@ -0,0 +1,30 @@
+// Create a personal access token returns "Created" response
+use chrono::{DateTime, Utc};
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_key_management::KeyManagementAPI;
+use datadog_api_client::datadogV2::model::PersonalAccessTokenCreateAttributes;
+use datadog_api_client::datadogV2::model::PersonalAccessTokenCreateData;
+use datadog_api_client::datadogV2::model::PersonalAccessTokenCreateRequest;
+use datadog_api_client::datadogV2::model::PersonalAccessTokensType;
+
+#[tokio::main]
+async fn main() {
+    let body = PersonalAccessTokenCreateRequest::new(PersonalAccessTokenCreateData::new(
+        PersonalAccessTokenCreateAttributes::new(
+            DateTime::parse_from_rfc3339("2022-11-11T11:11:11+00:00")
+                .expect("Failed to parse datetime")
+                .with_timezone(&Utc),
+            "Example-Personal-Access-Token".to_string(),
+            vec!["dashboards_read".to_string()],
+        ),
+        PersonalAccessTokensType::PERSONAL_ACCESS_TOKENS,
+    ));
+    let configuration = datadog::Configuration::new();
+    let api = KeyManagementAPI::with_config(configuration);
+    let resp = api.create_personal_access_token(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_key-management_CreatePersonalAccessToken.rs

@@ -0,0 +1,19 @@
+// Get a personal access token returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_key_management::KeyManagementAPI;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "personal_access_token" in the system
+    let personal_access_token_data_id = std::env::var("PERSONAL_ACCESS_TOKEN_DATA_ID").unwrap();
+    let configuration = datadog::Configuration::new();
+    let api = KeyManagementAPI::with_config(configuration);
+    let resp = api
+        .get_personal_access_token(personal_access_token_data_id.clone())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_key-management_GetPersonalAccessToken.rs

@@ -0,0 +1,18 @@
+// Get all personal access tokens returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_key_management::KeyManagementAPI;
+use datadog_api_client::datadogV2::api_key_management::ListPersonalAccessTokensOptionalParams;
+
+#[tokio::main]
+async fn main() {
+    let configuration = datadog::Configuration::new();
+    let api = KeyManagementAPI::with_config(configuration);
+    let resp = api
+        .list_personal_access_tokens(ListPersonalAccessTokensOptionalParams::default())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_key-management_ListPersonalAccessTokens.rs

@@ -0,0 +1,19 @@
+// Revoke a personal access token returns "No Content" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_key_management::KeyManagementAPI;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "personal_access_token" in the system
+    let personal_access_token_data_id = std::env::var("PERSONAL_ACCESS_TOKEN_DATA_ID").unwrap();
+    let configuration = datadog::Configuration::new();
+    let api = KeyManagementAPI::with_config(configuration);
+    let resp = api
+        .revoke_personal_access_token(personal_access_token_data_id.clone())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_key-management_RevokePersonalAccessToken.rs

@@ -0,0 +1,29 @@
+// Update a personal access token returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_key_management::KeyManagementAPI;
+use datadog_api_client::datadogV2::model::PersonalAccessTokenUpdateAttributes;
+use datadog_api_client::datadogV2::model::PersonalAccessTokenUpdateData;
+use datadog_api_client::datadogV2::model::PersonalAccessTokenUpdateRequest;
+use datadog_api_client::datadogV2::model::PersonalAccessTokensType;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "personal_access_token" in the system
+    let personal_access_token_data_id = std::env::var("PERSONAL_ACCESS_TOKEN_DATA_ID").unwrap();
+    let body = PersonalAccessTokenUpdateRequest::new(PersonalAccessTokenUpdateData::new(
+        PersonalAccessTokenUpdateAttributes::new()
+            .name("Example-Personal-Access-Token-updated".to_string()),
+        personal_access_token_data_id.clone(),
+        PersonalAccessTokensType::PERSONAL_ACCESS_TOKENS,
+    ));
+    let configuration = datadog::Configuration::new();
+    let api = KeyManagementAPI::with_config(configuration);
+    let resp = api
+        .update_personal_access_token(personal_access_token_data_id.clone(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_key-management_UpdatePersonalAccessToken.rs

@@ -0,0 +1,31 @@
+// Create an access token for a service account returns "Created" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_service_accounts::ServiceAccountsAPI;
+use datadog_api_client::datadogV2::model::PersonalAccessTokensType;
+use datadog_api_client::datadogV2::model::ServiceAccountAccessTokenCreateAttributes;
+use datadog_api_client::datadogV2::model::ServiceAccountAccessTokenCreateData;
+use datadog_api_client::datadogV2::model::ServiceAccountAccessTokenCreateRequest;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "service_account_user" in the system
+    let service_account_user_data_id = std::env::var("SERVICE_ACCOUNT_USER_DATA_ID").unwrap();
+    let body =
+        ServiceAccountAccessTokenCreateRequest::new(ServiceAccountAccessTokenCreateData::new(
+            ServiceAccountAccessTokenCreateAttributes::new(
+                "Example-Service-Account".to_string(),
+                vec!["dashboards_read".to_string()],
+            ),
+            PersonalAccessTokensType::PERSONAL_ACCESS_TOKENS,
+        ));
+    let configuration = datadog::Configuration::new();
+    let api = ServiceAccountsAPI::with_config(configuration);
+    let resp = api
+        .create_service_account_access_token(service_account_user_data_id.clone(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_service-accounts_CreateServiceAccountAccessToken.rs

@@ -0,0 +1,26 @@
+// Get an access token for a service account returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_service_accounts::ServiceAccountsAPI;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "service_account_user" in the system
+    let service_account_user_data_id = std::env::var("SERVICE_ACCOUNT_USER_DATA_ID").unwrap();
+
+    // there is a valid "service_account_access_token" for "service_account_user"
+    let service_account_access_token_data_id =
+        std::env::var("SERVICE_ACCOUNT_ACCESS_TOKEN_DATA_ID").unwrap();
+    let configuration = datadog::Configuration::new();
+    let api = ServiceAccountsAPI::with_config(configuration);
+    let resp = api
+        .get_service_account_access_token(
+            service_account_user_data_id.clone(),
+            service_account_access_token_data_id.clone(),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_service-accounts_GetServiceAccountAccessToken.rs

@@ -0,0 +1,23 @@
+// List access tokens for a service account returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_service_accounts::ListServiceAccountAccessTokensOptionalParams;
+use datadog_api_client::datadogV2::api_service_accounts::ServiceAccountsAPI;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "service_account_user" in the system
+    let service_account_user_data_id = std::env::var("SERVICE_ACCOUNT_USER_DATA_ID").unwrap();
+    let configuration = datadog::Configuration::new();
+    let api = ServiceAccountsAPI::with_config(configuration);
+    let resp = api
+        .list_service_account_access_tokens(
+            service_account_user_data_id.clone(),
+            ListServiceAccountAccessTokensOptionalParams::default(),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_service-accounts_ListServiceAccountAccessTokens.rs

@@ -0,0 +1,26 @@
+// Revoke an access token for a service account returns "No Content" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_service_accounts::ServiceAccountsAPI;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "service_account_user" in the system
+    let service_account_user_data_id = std::env::var("SERVICE_ACCOUNT_USER_DATA_ID").unwrap();
+
+    // there is a valid "service_account_access_token" for "service_account_user"
+    let service_account_access_token_data_id =
+        std::env::var("SERVICE_ACCOUNT_ACCESS_TOKEN_DATA_ID").unwrap();
+    let configuration = datadog::Configuration::new();
+    let api = ServiceAccountsAPI::with_config(configuration);
+    let resp = api
+        .revoke_service_account_access_token(
+            service_account_user_data_id.clone(),
+            service_account_access_token_data_id.clone(),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}