Add action datastore API (#882)

Co-authored-by: ci.datadog-api-spec <packages@datadoghq.com>

Author: api-clients-generation-pipeline[bot]

.generator/schemas/v2/openapi.yaml

@@ -0,0 +1,39 @@
+// Bulk write datastore items returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_actions_datastores::ActionsDatastoresAPI;
+use datadog_api_client::datadogV2::model::BulkPutAppsDatastoreItemsRequest;
+use datadog_api_client::datadogV2::model::BulkPutAppsDatastoreItemsRequestData;
+use datadog_api_client::datadogV2::model::BulkPutAppsDatastoreItemsRequestDataAttributes;
+use datadog_api_client::datadogV2::model::DatastoreItemsDataType;
+use serde_json::Value;
+use std::collections::BTreeMap;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "datastore" in the system
+    let datastore_data_id = std::env::var("DATASTORE_DATA_ID").unwrap();
+    let body = BulkPutAppsDatastoreItemsRequest::new().data(
+        BulkPutAppsDatastoreItemsRequestData::new(DatastoreItemsDataType::ITEMS).attributes(
+            BulkPutAppsDatastoreItemsRequestDataAttributes::new(vec![
+                BTreeMap::from([
+                    ("id".to_string(), Value::from("cust_3141")),
+                    ("name".to_string(), Value::from("Johnathan")),
+                ]),
+                BTreeMap::from([
+                    ("id".to_string(), Value::from("cust_3142")),
+                    ("name".to_string(), Value::from("Mary")),
+                ]),
+            ]),
+        ),
+    );
+    let configuration = datadog::Configuration::new();
+    let api = ActionsDatastoresAPI::with_config(configuration);
+    let resp = api
+        .bulk_write_datastore_items(datastore_data_id.clone(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_actions-datastores_BulkWriteDatastoreItems.rs

@@ -0,0 +1,27 @@
+// Create datastore returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_actions_datastores::ActionsDatastoresAPI;
+use datadog_api_client::datadogV2::model::CreateAppsDatastoreRequest;
+use datadog_api_client::datadogV2::model::CreateAppsDatastoreRequestData;
+use datadog_api_client::datadogV2::model::CreateAppsDatastoreRequestDataAttributes;
+use datadog_api_client::datadogV2::model::DatastoreDataType;
+
+#[tokio::main]
+async fn main() {
+    let body = CreateAppsDatastoreRequest::new().data(
+        CreateAppsDatastoreRequestData::new(DatastoreDataType::DATASTORES).attributes(
+            CreateAppsDatastoreRequestDataAttributes::new(
+                "datastore-name".to_string(),
+                "primaryKey".to_string(),
+            ),
+        ),
+    );
+    let configuration = datadog::Configuration::new();
+    let api = ActionsDatastoresAPI::with_config(configuration);
+    let resp = api.create_datastore(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_actions-datastores_CreateDatastore.rs

@@ -0,0 +1,17 @@
+// Delete datastore returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_actions_datastores::ActionsDatastoresAPI;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "datastore" in the system
+    let datastore_data_id = std::env::var("DATASTORE_DATA_ID").unwrap();
+    let configuration = datadog::Configuration::new();
+    let api = ActionsDatastoresAPI::with_config(configuration);
+    let resp = api.delete_datastore(datastore_data_id.clone()).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_actions-datastores_DeleteDatastore.rs

@@ -0,0 +1,28 @@
+// Delete datastore item returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_actions_datastores::ActionsDatastoresAPI;
+use datadog_api_client::datadogV2::model::DatastoreItemsDataType;
+use datadog_api_client::datadogV2::model::DeleteAppsDatastoreItemRequest;
+use datadog_api_client::datadogV2::model::DeleteAppsDatastoreItemRequestData;
+use datadog_api_client::datadogV2::model::DeleteAppsDatastoreItemRequestDataAttributes;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "datastore" in the system
+    let datastore_data_id = std::env::var("DATASTORE_DATA_ID").unwrap();
+    let body = DeleteAppsDatastoreItemRequest::new().data(
+        DeleteAppsDatastoreItemRequestData::new(DatastoreItemsDataType::ITEMS).attributes(
+            DeleteAppsDatastoreItemRequestDataAttributes::new("test-key".to_string()),
+        ),
+    );
+    let configuration = datadog::Configuration::new();
+    let api = ActionsDatastoresAPI::with_config(configuration);
+    let resp = api
+        .delete_datastore_item(datastore_data_id.clone(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_actions-datastores_DeleteDatastoreItem.rs

@@ -0,0 +1,17 @@
+// Get datastore returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_actions_datastores::ActionsDatastoresAPI;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "datastore" in the system
+    let datastore_data_id = std::env::var("DATASTORE_DATA_ID").unwrap();
+    let configuration = datadog::Configuration::new();
+    let api = ActionsDatastoresAPI::with_config(configuration);
+    let resp = api.get_datastore(datastore_data_id.clone()).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_actions-datastores_GetDatastore.rs

@@ -0,0 +1,23 @@
+// List datastore items returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_actions_datastores::ActionsDatastoresAPI;
+use datadog_api_client::datadogV2::api_actions_datastores::ListDatastoreItemsOptionalParams;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "datastore" in the system
+    let datastore_data_id = std::env::var("DATASTORE_DATA_ID").unwrap();
+    let configuration = datadog::Configuration::new();
+    let api = ActionsDatastoresAPI::with_config(configuration);
+    let resp = api
+        .list_datastore_items(
+            datastore_data_id.clone(),
+            ListDatastoreItemsOptionalParams::default(),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_actions-datastores_ListDatastoreItems.rs

@@ -0,0 +1,15 @@
+// List datastores returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_actions_datastores::ActionsDatastoresAPI;
+
+#[tokio::main]
+async fn main() {
+    let configuration = datadog::Configuration::new();
+    let api = ActionsDatastoresAPI::with_config(configuration);
+    let resp = api.list_datastores().await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_actions-datastores_ListDatastores.rs

@@ -0,0 +1,28 @@
+// Update datastore returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_actions_datastores::ActionsDatastoresAPI;
+use datadog_api_client::datadogV2::model::DatastoreDataType;
+use datadog_api_client::datadogV2::model::UpdateAppsDatastoreRequest;
+use datadog_api_client::datadogV2::model::UpdateAppsDatastoreRequestData;
+use datadog_api_client::datadogV2::model::UpdateAppsDatastoreRequestDataAttributes;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "datastore" in the system
+    let datastore_data_id = std::env::var("DATASTORE_DATA_ID").unwrap();
+    let body = UpdateAppsDatastoreRequest::new().data(
+        UpdateAppsDatastoreRequestData::new(DatastoreDataType::DATASTORES)
+            .attributes(
+                UpdateAppsDatastoreRequestDataAttributes::new().name("updated name".to_string()),
+            )
+            .id(datastore_data_id.clone()),
+    );
+    let configuration = datadog::Configuration::new();
+    let api = ActionsDatastoresAPI::with_config(configuration);
+    let resp = api.update_datastore(datastore_data_id.clone(), body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_actions-datastores_UpdateDatastore.rs

@@ -0,0 +1,31 @@
+// Update datastore item returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_actions_datastores::ActionsDatastoresAPI;
+use datadog_api_client::datadogV2::model::UpdateAppsDatastoreItemRequest;
+use datadog_api_client::datadogV2::model::UpdateAppsDatastoreItemRequestData;
+use datadog_api_client::datadogV2::model::UpdateAppsDatastoreItemRequestDataAttributes;
+use datadog_api_client::datadogV2::model::UpdateAppsDatastoreItemRequestDataAttributesItemChanges;
+use datadog_api_client::datadogV2::model::UpdateAppsDatastoreItemRequestDataType;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "datastore" in the system
+    let datastore_data_id = std::env::var("DATASTORE_DATA_ID").unwrap();
+    let body = UpdateAppsDatastoreItemRequest::new().data(
+        UpdateAppsDatastoreItemRequestData::new(UpdateAppsDatastoreItemRequestDataType::ITEMS)
+            .attributes(UpdateAppsDatastoreItemRequestDataAttributes::new(
+                UpdateAppsDatastoreItemRequestDataAttributesItemChanges::new(),
+                "test-key".to_string(),
+            )),
+    );
+    let configuration = datadog::Configuration::new();
+    let api = ActionsDatastoresAPI::with_config(configuration);
+    let resp = api
+        .update_datastore_item(datastore_data_id.clone(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}