Add Reference Tables API spec

examples/v2_reference-tables_CreateReferenceTable.rs

@@ -0,0 +1,72 @@
+// Create reference table returns "Created" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_reference_tables::ReferenceTablesAPI;
+use datadog_api_client::datadogV2::model::CreateTableRequest;
+use datadog_api_client::datadogV2::model::CreateTableRequestData;
+use datadog_api_client::datadogV2::model::CreateTableRequestDataAttributes;
+use datadog_api_client::datadogV2::model::CreateTableRequestDataAttributesFileMetadata;
+use datadog_api_client::datadogV2::model::CreateTableRequestDataAttributesFileMetadataCloudStorage;
+use datadog_api_client::datadogV2::model::CreateTableRequestDataAttributesFileMetadataOneOfAccessDetails;
+use datadog_api_client::datadogV2::model::CreateTableRequestDataAttributesFileMetadataOneOfAccessDetailsAwsDetail;
+use datadog_api_client::datadogV2::model::CreateTableRequestDataAttributesSchema;
+use datadog_api_client::datadogV2::model::CreateTableRequestDataAttributesSchemaFieldsItems;
+use datadog_api_client::datadogV2::model::CreateTableRequestDataType;
+use datadog_api_client::datadogV2::model::ReferenceTableCreateSourceType;
+use datadog_api_client::datadogV2::model::ReferenceTableSchemaFieldType;
+
+#[tokio::main]
+async fn main() {
+    let body =
+        CreateTableRequest
+        ::new().data(
+            CreateTableRequestData::new(
+                CreateTableRequestDataType::REFERENCE_TABLE,
+            ).attributes(
+                CreateTableRequestDataAttributes::new(
+                    CreateTableRequestDataAttributesSchema::new(
+                        vec![
+                            CreateTableRequestDataAttributesSchemaFieldsItems::new(
+                                "name".to_string(),
+                                ReferenceTableSchemaFieldType::STRING,
+                            ),
+                            CreateTableRequestDataAttributesSchemaFieldsItems::new(
+                                "account_id".to_string(),
+                                ReferenceTableSchemaFieldType::STRING,
+                            )
+                        ],
+                        vec!["account_id".to_string()],
+                    ),
+                    ReferenceTableCreateSourceType::S3,
+                    "test_reference_table".to_string(),
+                )
+                    .description("this is a cloud table generated via a cloud bucket sync".to_string())
+                    .file_metadata(
+                        CreateTableRequestDataAttributesFileMetadata
+                        ::CreateTableRequestDataAttributesFileMetadataCloudStorage(
+                            Box::new(
+                                CreateTableRequestDataAttributesFileMetadataCloudStorage::new(
+                                    CreateTableRequestDataAttributesFileMetadataOneOfAccessDetails
+                                    ::new().aws_detail(
+                                        CreateTableRequestDataAttributesFileMetadataOneOfAccessDetailsAwsDetail::new(
+                                            "test-account-id".to_string(),
+                                            "test-bucket".to_string(),
+                                            "test_rt.csv".to_string(),
+                                        ),
+                                    ),
+                                    true,
+                                ),
+                            ),
+                        ),
+                    )
+                    .tags(vec!["test_tag".to_string()]),
+            ),
+        );
+    let configuration = datadog::Configuration::new();
+    let api = ReferenceTablesAPI::with_config(configuration);
+    let resp = api.create_reference_table(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_reference-tables_CreateReferenceTableUpload.rs

@@ -0,0 +1,29 @@
+// Create reference table upload returns "Created" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_reference_tables::ReferenceTablesAPI;
+use datadog_api_client::datadogV2::model::CreateUploadRequest;
+use datadog_api_client::datadogV2::model::CreateUploadRequestData;
+use datadog_api_client::datadogV2::model::CreateUploadRequestDataAttributes;
+use datadog_api_client::datadogV2::model::CreateUploadRequestDataType;
+
+#[tokio::main]
+async fn main() {
+    let body = CreateUploadRequest::new().data(
+        CreateUploadRequestData::new(CreateUploadRequestDataType::UPLOAD).attributes(
+            CreateUploadRequestDataAttributes::new(
+                vec!["id".to_string(), "name".to_string(), "value".to_string()],
+                1,
+                1024,
+                "test_upload_table_Example-Reference-Table".to_string(),
+            ),
+        ),
+    );
+    let configuration = datadog::Configuration::new();
+    let api = ReferenceTablesAPI::with_config(configuration);
+    let resp = api.create_reference_table_upload(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_reference-tables_CreateReferenceTable_3196130987.rs

@@ -0,0 +1,66 @@
+// Create reference table with upload returns "Created" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_reference_tables::ReferenceTablesAPI;
+use datadog_api_client::datadogV2::model::CreateTableRequest;
+use datadog_api_client::datadogV2::model::CreateTableRequestData;
+use datadog_api_client::datadogV2::model::CreateTableRequestDataAttributes;
+use datadog_api_client::datadogV2::model::CreateTableRequestDataAttributesFileMetadata;
+use datadog_api_client::datadogV2::model::CreateTableRequestDataAttributesFileMetadataLocalFile;
+use datadog_api_client::datadogV2::model::CreateTableRequestDataAttributesSchema;
+use datadog_api_client::datadogV2::model::CreateTableRequestDataAttributesSchemaFieldsItems;
+use datadog_api_client::datadogV2::model::CreateTableRequestDataType;
+use datadog_api_client::datadogV2::model::ReferenceTableCreateSourceType;
+use datadog_api_client::datadogV2::model::ReferenceTableSchemaFieldType;
+
+#[tokio::main]
+async fn main() {
+    let body =
+        CreateTableRequest
+        ::new().data(
+            CreateTableRequestData::new(
+                CreateTableRequestDataType::REFERENCE_TABLE,
+            ).attributes(
+                CreateTableRequestDataAttributes::new(
+                    CreateTableRequestDataAttributesSchema::new(
+                        vec![
+                            CreateTableRequestDataAttributesSchemaFieldsItems::new(
+                                "id".to_string(),
+                                ReferenceTableSchemaFieldType::STRING,
+                            ),
+                            CreateTableRequestDataAttributesSchemaFieldsItems::new(
+                                "name".to_string(),
+                                ReferenceTableSchemaFieldType::STRING,
+                            ),
+                            CreateTableRequestDataAttributesSchemaFieldsItems::new(
+                                "value".to_string(),
+                                ReferenceTableSchemaFieldType::INT32,
+                            )
+                        ],
+                        vec!["id".to_string()],
+                    ),
+                    ReferenceTableCreateSourceType::LOCAL_FILE,
+                    "test_reference_table_Example-Reference-Table".to_string(),
+                )
+                    .description("Test reference table created via BDD test Example-Reference-Table".to_string())
+                    .file_metadata(
+                        CreateTableRequestDataAttributesFileMetadata
+                        ::CreateTableRequestDataAttributesFileMetadataLocalFile(
+                            Box::new(
+                                CreateTableRequestDataAttributesFileMetadataLocalFile::new(
+                                    "test-upload-id-Example-Reference-Table".to_string(),
+                                ),
+                            ),
+                        ),
+                    )
+                    .tags(vec!["test_tag".to_string()]),
+            ),
+        );
+    let configuration = datadog::Configuration::new();
+    let api = ReferenceTablesAPI::with_config(configuration);
+    let resp = api.create_reference_table(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_reference-tables_DeleteTable.rs

@@ -0,0 +1,15 @@
+// Delete table returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_reference_tables::ReferenceTablesAPI;
+
+#[tokio::main]
+async fn main() {
+    let configuration = datadog::Configuration::new();
+    let api = ReferenceTablesAPI::with_config(configuration);
+    let resp = api.delete_table("id".to_string()).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_reference-tables_GetRowsByID.rs

@@ -0,0 +1,15 @@
+// Get rows by id returns "Some or all requested rows were found." response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_reference_tables::ReferenceTablesAPI;
+
+#[tokio::main]
+async fn main() {
+    let configuration = datadog::Configuration::new();
+    let api = ReferenceTablesAPI::with_config(configuration);
+    let resp = api.get_rows_by_id("id".to_string(), vec![]).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_reference-tables_GetTable.rs

@@ -0,0 +1,15 @@
+// Get table returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_reference_tables::ReferenceTablesAPI;
+
+#[tokio::main]
+async fn main() {
+    let configuration = datadog::Configuration::new();
+    let api = ReferenceTablesAPI::with_config(configuration);
+    let resp = api.get_table("id".to_string()).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_reference-tables_ListTables.rs

@@ -0,0 +1,16 @@
+// List tables returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_reference_tables::ListTablesOptionalParams;
+use datadog_api_client::datadogV2::api_reference_tables::ReferenceTablesAPI;
+
+#[tokio::main]
+async fn main() {
+    let configuration = datadog::Configuration::new();
+    let api = ReferenceTablesAPI::with_config(configuration);
+    let resp = api.list_tables(ListTablesOptionalParams::default()).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_reference-tables_UpdateReferenceTable.rs

@@ -0,0 +1,72 @@
+// Update reference table returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_reference_tables::ReferenceTablesAPI;
+use datadog_api_client::datadogV2::model::PatchTableRequest;
+use datadog_api_client::datadogV2::model::PatchTableRequestData;
+use datadog_api_client::datadogV2::model::PatchTableRequestDataAttributes;
+use datadog_api_client::datadogV2::model::PatchTableRequestDataAttributesFileMetadata;
+use datadog_api_client::datadogV2::model::PatchTableRequestDataAttributesFileMetadataCloudStorage;
+use datadog_api_client::datadogV2::model::PatchTableRequestDataAttributesFileMetadataOneOfAccessDetails;
+use datadog_api_client::datadogV2::model::PatchTableRequestDataAttributesFileMetadataOneOfAccessDetailsAwsDetail;
+use datadog_api_client::datadogV2::model::PatchTableRequestDataAttributesSchema;
+use datadog_api_client::datadogV2::model::PatchTableRequestDataAttributesSchemaFieldsItems;
+use datadog_api_client::datadogV2::model::PatchTableRequestDataType;
+use datadog_api_client::datadogV2::model::ReferenceTableSchemaFieldType;
+
+#[tokio::main]
+async fn main() {
+    let body =
+        PatchTableRequest
+        ::new().data(
+            PatchTableRequestData::new(PatchTableRequestDataType::REFERENCE_TABLE)
+                .attributes(
+                    PatchTableRequestDataAttributes::new()
+                        .description("this is a cloud table generated via a cloud bucket sync".to_string())
+                        .file_metadata(
+                            PatchTableRequestDataAttributesFileMetadata
+                            ::PatchTableRequestDataAttributesFileMetadataCloudStorage(
+                                Box::new(
+                                    PatchTableRequestDataAttributesFileMetadataCloudStorage::new()
+                                        .access_details(
+                                            PatchTableRequestDataAttributesFileMetadataOneOfAccessDetails
+                                            ::new().aws_detail(
+                                                PatchTableRequestDataAttributesFileMetadataOneOfAccessDetailsAwsDetail
+                                                ::new()
+                                                    .aws_account_id("test-account-id".to_string())
+                                                    .aws_bucket_name("test-bucket".to_string())
+                                                    .file_path("test_rt.csv".to_string()),
+                                            ),
+                                        )
+                                        .sync_enabled(true),
+                                ),
+                            ),
+                        )
+                        .schema(
+                            PatchTableRequestDataAttributesSchema::new(
+                                vec![
+                                    PatchTableRequestDataAttributesSchemaFieldsItems::new(
+                                        "id".to_string(),
+                                        ReferenceTableSchemaFieldType::INT32,
+                                    ),
+                                    PatchTableRequestDataAttributesSchemaFieldsItems::new(
+                                        "name".to_string(),
+                                        ReferenceTableSchemaFieldType::STRING,
+                                    )
+                                ],
+                                vec!["id".to_string()],
+                            ),
+                        )
+                        .sync_enabled(false)
+                        .tags(vec!["test_tag".to_string()]),
+                )
+                .id("00000000-0000-0000-0000-000000000000".to_string()),
+        );
+    let configuration = datadog::Configuration::new();
+    let api = ReferenceTablesAPI::with_config(configuration);
+    let resp = api.update_reference_table("id".to_string(), body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}