Regenerate client from commit 73c1307 of spec repo

Author: ci.datadog-api-spec

.generator/schemas/v2/openapi.yaml

@@ -0,0 +1,48 @@
+// Create connection returns "Connection created successfully" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_rum_audience_management::RumAudienceManagementAPI;
+use datadog_api_client::datadogV2::model::CreateConnectionRequest;
+use datadog_api_client::datadogV2::model::CreateConnectionRequestData;
+use datadog_api_client::datadogV2::model::CreateConnectionRequestDataAttributes;
+use datadog_api_client::datadogV2::model::CreateConnectionRequestDataAttributesFieldsItems;
+use datadog_api_client::datadogV2::model::UpdateConnectionRequestDataType;
+
+#[tokio::main]
+async fn main() {
+    let body = CreateConnectionRequest::new().data(
+        CreateConnectionRequestData::new(UpdateConnectionRequestDataType::CONNECTION_ID)
+            .attributes(
+                CreateConnectionRequestDataAttributes::new(
+                    "user_email".to_string(),
+                    "email".to_string(),
+                    "ref_table".to_string(),
+                )
+                .fields(vec![
+                    CreateConnectionRequestDataAttributesFieldsItems::new(
+                        "customer_tier".to_string(),
+                        "subscription_tier".to_string(),
+                        "string".to_string(),
+                    )
+                    .description(r#"Customer subscription tier from `CRM`"#.to_string())
+                    .display_name("Customer Tier".to_string()),
+                    CreateConnectionRequestDataAttributesFieldsItems::new(
+                        "lifetime_value".to_string(),
+                        "ltv".to_string(),
+                        "number".to_string(),
+                    )
+                    .description(r#"Customer lifetime value in `USD`"#.to_string())
+                    .display_name("Lifetime Value".to_string()),
+                ]),
+            )
+            .id("crm-integration".to_string()),
+    );
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.CreateConnection", true);
+    let api = RumAudienceManagementAPI::with_config(configuration);
+    let resp = api.create_connection("users".to_string(), body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_rum-audience-management_CreateConnection.rs

@@ -0,0 +1,18 @@
+// Delete connection returns "Connection deleted successfully" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_rum_audience_management::RumAudienceManagementAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.DeleteConnection", true);
+    let api = RumAudienceManagementAPI::with_config(configuration);
+    let resp = api
+        .delete_connection("connection-id-123".to_string(), "users".to_string())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_rum-audience-management_DeleteConnection.rs

@@ -0,0 +1,37 @@
+// Get account facet info returns "Successful response with facet information"
+// response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_rum_audience_management::RumAudienceManagementAPI;
+use datadog_api_client::datadogV2::model::FacetInfoRequest;
+use datadog_api_client::datadogV2::model::FacetInfoRequestData;
+use datadog_api_client::datadogV2::model::FacetInfoRequestDataAttributes;
+use datadog_api_client::datadogV2::model::FacetInfoRequestDataAttributesSearch;
+use datadog_api_client::datadogV2::model::FacetInfoRequestDataAttributesTermSearch;
+use datadog_api_client::datadogV2::model::FacetInfoRequestDataType;
+
+#[tokio::main]
+async fn main() {
+    let body = FacetInfoRequest::new().data(
+        FacetInfoRequestData::new(FacetInfoRequestDataType::USERS_FACET_INFO_REQUEST)
+            .attributes(
+                FacetInfoRequestDataAttributes::new("first_browser_name".to_string(), 10)
+                    .search(
+                        FacetInfoRequestDataAttributesSearch::new()
+                            .query("user_org_id:5001 AND first_country_code:US".to_string()),
+                    )
+                    .term_search(
+                        FacetInfoRequestDataAttributesTermSearch::new().value("Chrome".to_string()),
+                    ),
+            )
+            .id("facet_info_request".to_string()),
+    );
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.GetAccountFacetInfo", true);
+    let api = RumAudienceManagementAPI::with_config(configuration);
+    let resp = api.get_account_facet_info(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_rum-audience-management_GetAccountFacetInfo.rs

@@ -0,0 +1,17 @@
+// Get mapping returns "Successful response with entity mapping configuration"
+// response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_rum_audience_management::RumAudienceManagementAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.GetMapping", true);
+    let api = RumAudienceManagementAPI::with_config(configuration);
+    let resp = api.get_mapping("users".to_string()).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_rum-audience-management_GetMapping.rs

@@ -0,0 +1,37 @@
+// Get user facet info returns "Successful response with facet information"
+// response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_rum_audience_management::RumAudienceManagementAPI;
+use datadog_api_client::datadogV2::model::FacetInfoRequest;
+use datadog_api_client::datadogV2::model::FacetInfoRequestData;
+use datadog_api_client::datadogV2::model::FacetInfoRequestDataAttributes;
+use datadog_api_client::datadogV2::model::FacetInfoRequestDataAttributesSearch;
+use datadog_api_client::datadogV2::model::FacetInfoRequestDataAttributesTermSearch;
+use datadog_api_client::datadogV2::model::FacetInfoRequestDataType;
+
+#[tokio::main]
+async fn main() {
+    let body = FacetInfoRequest::new().data(
+        FacetInfoRequestData::new(FacetInfoRequestDataType::USERS_FACET_INFO_REQUEST)
+            .attributes(
+                FacetInfoRequestDataAttributes::new("first_browser_name".to_string(), 10)
+                    .search(
+                        FacetInfoRequestDataAttributesSearch::new()
+                            .query("user_org_id:5001 AND first_country_code:US".to_string()),
+                    )
+                    .term_search(
+                        FacetInfoRequestDataAttributesTermSearch::new().value("Chrome".to_string()),
+                    ),
+            )
+            .id("facet_info_request".to_string()),
+    );
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.GetUserFacetInfo", true);
+    let api = RumAudienceManagementAPI::with_config(configuration);
+    let resp = api.get_user_facet_info(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_rum-audience-management_GetUserFacetInfo.rs

@@ -0,0 +1,16 @@
+// List connections returns "Successful response with list of connections" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_rum_audience_management::RumAudienceManagementAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.ListConnections", true);
+    let api = RumAudienceManagementAPI::with_config(configuration);
+    let resp = api.list_connections("users".to_string()).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_rum-audience-management_ListConnections.rs

@@ -0,0 +1,49 @@
+// Query accounts returns "Successful response with account data" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_rum_audience_management::RumAudienceManagementAPI;
+use datadog_api_client::datadogV2::model::QueryAccountRequest;
+use datadog_api_client::datadogV2::model::QueryAccountRequestData;
+use datadog_api_client::datadogV2::model::QueryAccountRequestDataAttributes;
+use datadog_api_client::datadogV2::model::QueryAccountRequestDataAttributesSort;
+use datadog_api_client::datadogV2::model::QueryAccountRequestDataType;
+
+#[tokio::main]
+async fn main() {
+    let body = QueryAccountRequest::new().data(
+        QueryAccountRequestData::new(QueryAccountRequestDataType::QUERY_ACCOUNT_REQUEST)
+            .attributes(
+                QueryAccountRequestDataAttributes::new()
+                    .limit(20)
+                    .query(
+                        "plan_type:enterprise AND user_count:>100 AND subscription_status:active"
+                            .to_string(),
+                    )
+                    .select_columns(vec![
+                        "account_id".to_string(),
+                        "account_name".to_string(),
+                        "user_count".to_string(),
+                        "plan_type".to_string(),
+                        "subscription_status".to_string(),
+                        "created_at".to_string(),
+                        "mrr".to_string(),
+                        "industry".to_string(),
+                    ])
+                    .sort(
+                        QueryAccountRequestDataAttributesSort::new()
+                            .field("user_count".to_string())
+                            .order("DESC".to_string()),
+                    )
+                    .wildcard_search_term("tech".to_string()),
+            )
+            .id("query_account_request".to_string()),
+    );
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.QueryAccounts", true);
+    let api = RumAudienceManagementAPI::with_config(configuration);
+    let resp = api.query_accounts(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_rum-audience-management_QueryAccounts.rs

@@ -0,0 +1,60 @@
+// Query event filtered users returns "Successful response with filtered user
+// data" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_rum_audience_management::RumAudienceManagementAPI;
+use datadog_api_client::datadogV2::model::QueryEventFilteredUsersRequest;
+use datadog_api_client::datadogV2::model::QueryEventFilteredUsersRequestData;
+use datadog_api_client::datadogV2::model::QueryEventFilteredUsersRequestDataAttributes;
+use datadog_api_client::datadogV2::model::QueryEventFilteredUsersRequestDataAttributesEventQuery;
+use datadog_api_client::datadogV2::model::QueryEventFilteredUsersRequestDataAttributesEventQueryTimeFrame;
+use datadog_api_client::datadogV2::model::QueryEventFilteredUsersRequestDataType;
+
+#[tokio::main]
+async fn main() {
+    let body =
+        QueryEventFilteredUsersRequest
+        ::new().data(
+            QueryEventFilteredUsersRequestData::new(
+                QueryEventFilteredUsersRequestDataType::QUERY_EVENT_FILTERED_USERS_REQUEST,
+            )
+                .attributes(
+                    QueryEventFilteredUsersRequestDataAttributes::new()
+                        .event_query(
+                            QueryEventFilteredUsersRequestDataAttributesEventQuery::new()
+                                .query(
+                                    "@type:view AND @view.loading_time:>3000 AND @application.name:ecommerce-platform".to_string(),
+                                )
+                                .time_frame(
+                                    QueryEventFilteredUsersRequestDataAttributesEventQueryTimeFrame::new()
+                                        .end(1761309676)
+                                        .start(1760100076),
+                                ),
+                        )
+                        .include_row_count(true)
+                        .limit(25)
+                        .query("user_org_id:5001 AND first_country_code:US AND first_browser_name:Chrome".to_string())
+                        .select_columns(
+                            vec![
+                                "user_id".to_string(),
+                                "user_email".to_string(),
+                                "first_country_code".to_string(),
+                                "first_browser_name".to_string(),
+                                "events_count".to_string(),
+                                "session_count".to_string(),
+                                "error_count".to_string(),
+                                "avg_loading_time".to_string()
+                            ],
+                        ),
+                )
+                .id("query_event_filtered_users_request".to_string()),
+        );
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.QueryEventFilteredUsers", true);
+    let api = RumAudienceManagementAPI::with_config(configuration);
+    let resp = api.query_event_filtered_users(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_rum-audience-management_QueryEventFilteredUsers.rs

@@ -0,0 +1,52 @@
+// Query users returns "Successful response with user data" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_rum_audience_management::RumAudienceManagementAPI;
+use datadog_api_client::datadogV2::model::QueryUsersRequest;
+use datadog_api_client::datadogV2::model::QueryUsersRequestData;
+use datadog_api_client::datadogV2::model::QueryUsersRequestDataAttributes;
+use datadog_api_client::datadogV2::model::QueryUsersRequestDataAttributesSort;
+use datadog_api_client::datadogV2::model::QueryUsersRequestDataType;
+
+#[tokio::main]
+async fn main() {
+    let body =
+        QueryUsersRequest
+        ::new().data(
+            QueryUsersRequestData::new(QueryUsersRequestDataType::QUERY_USERS_REQUEST)
+                .attributes(
+                    QueryUsersRequestDataAttributes::new()
+                        .limit(25)
+                        .query(
+                            "user_email:*@techcorp.com AND first_country_code:US AND first_browser_name:Chrome".to_string(),
+                        )
+                        .select_columns(
+                            vec![
+                                "user_id".to_string(),
+                                "user_email".to_string(),
+                                "user_name".to_string(),
+                                "user_org_id".to_string(),
+                                "first_country_code".to_string(),
+                                "first_browser_name".to_string(),
+                                "first_device_type".to_string(),
+                                "last_seen".to_string()
+                            ],
+                        )
+                        .sort(
+                            QueryUsersRequestDataAttributesSort::new()
+                                .field("first_seen".to_string())
+                                .order("DESC".to_string()),
+                        )
+                        .wildcard_search_term("john".to_string()),
+                )
+                .id("query_users_request".to_string()),
+        );
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.QueryUsers", true);
+    let api = RumAudienceManagementAPI::with_config(configuration);
+    let resp = api.query_users(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}