Regenerate client from commit 06ae2bd of spec repo

Author: ci.datadog-api-spec

.generator/schemas/v2/openapi.yaml

@@ -0,0 +1,83 @@
+// Create targeting rules for a flag env returns "Created" response
+use chrono::{DateTime, Utc};
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_feature_flags::FeatureFlagsAPI;
+use datadog_api_client::datadogV2::model::AllocationDataRequest;
+use datadog_api_client::datadogV2::model::AllocationDataType;
+use datadog_api_client::datadogV2::model::AllocationType;
+use datadog_api_client::datadogV2::model::ConditionOperator;
+use datadog_api_client::datadogV2::model::ConditionRequest;
+use datadog_api_client::datadogV2::model::CreateAllocationsRequest;
+use datadog_api_client::datadogV2::model::ExposureRolloutStepRequest;
+use datadog_api_client::datadogV2::model::ExposureScheduleRequest;
+use datadog_api_client::datadogV2::model::GuardrailMetricRequest;
+use datadog_api_client::datadogV2::model::GuardrailTriggerAction;
+use datadog_api_client::datadogV2::model::RolloutOptionsRequest;
+use datadog_api_client::datadogV2::model::RolloutStrategy;
+use datadog_api_client::datadogV2::model::TargetingRuleRequest;
+use datadog_api_client::datadogV2::model::UpsertAllocationRequest;
+use datadog_api_client::datadogV2::model::VariantWeightRequest;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() {
+    let body = CreateAllocationsRequest::new(AllocationDataRequest::new(
+        UpsertAllocationRequest::new(
+            "prod-rollout".to_string(),
+            "Production Rollout".to_string(),
+            AllocationType::FEATURE_GATE,
+        )
+        .experiment_id(Some("550e8400-e29b-41d4-a716-446655440030".to_string()))
+        .exposure_schedule(
+            ExposureScheduleRequest::new(
+                RolloutOptionsRequest::new(RolloutStrategy::UNIFORM_INTERVALS)
+                    .autostart(Some(false))
+                    .selection_interval_ms(3600000),
+                vec![ExposureRolloutStepRequest::new(0.5, 1, false)
+                    .id(Uuid::parse_str("550e8400-e29b-41d4-a716-446655440040")
+                        .expect("invalid UUID"))
+                    .interval_ms(Some(3600000))],
+            )
+            .absolute_start_time(Some(
+                DateTime::parse_from_rfc3339("2025-06-13T12:00:00+00:00")
+                    .expect("Failed to parse datetime")
+                    .with_timezone(&Utc),
+            ))
+            .control_variant_id(Some("550e8400-e29b-41d4-a716-446655440012".to_string()))
+            .control_variant_key(Some("control".to_string()))
+            .id(Uuid::parse_str("550e8400-e29b-41d4-a716-446655440010").expect("invalid UUID")),
+        )
+        .guardrail_metrics(vec![GuardrailMetricRequest::new(
+            "metric-error-rate".to_string(),
+            GuardrailTriggerAction::PAUSE,
+        )])
+        .id(Uuid::parse_str("550e8400-e29b-41d4-a716-446655440020").expect("invalid UUID"))
+        .targeting_rules(vec![TargetingRuleRequest::new(vec![
+            ConditionRequest::new(
+                "user_tier".to_string(),
+                ConditionOperator::ONE_OF,
+                vec!["premium".to_string(), "enterprise".to_string()],
+            ),
+        ])])
+        .variant_weights(vec![VariantWeightRequest::new(50.0)
+            .variant_id(
+                Uuid::parse_str("550e8400-e29b-41d4-a716-446655440001").expect("invalid UUID"),
+            )
+            .variant_key("control".to_string())]),
+        AllocationDataType::ALLOCATIONS,
+    ));
+    let configuration = datadog::Configuration::new();
+    let api = FeatureFlagsAPI::with_config(configuration);
+    let resp = api
+        .create_allocations_for_feature_flag_in_environment(
+            Uuid::parse_str("550e8400-e29b-41d4-a716-446655440000").expect("invalid UUID"),
+            Uuid::parse_str("550e8400-e29b-41d4-a716-446655440001").expect("invalid UUID"),
+            body,
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_feature-flags_CreateAllocationsForFeatureFlagInEnvironment.rs

@@ -0,0 +1,51 @@
+// Create allocation for a flag in an environment returns "Created" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_feature_flags::FeatureFlagsAPI;
+use datadog_api_client::datadogV2::model::AllocationDataRequest;
+use datadog_api_client::datadogV2::model::AllocationDataType;
+use datadog_api_client::datadogV2::model::AllocationType;
+use datadog_api_client::datadogV2::model::CreateAllocationsRequest;
+use datadog_api_client::datadogV2::model::UpsertAllocationRequest;
+use datadog_api_client::datadogV2::model::VariantWeightRequest;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "feature_flag" in the system
+    let feature_flag_data_attributes_variants_0_id = uuid::Uuid::parse_str(
+        &std::env::var("FEATURE_FLAG_DATA_ATTRIBUTES_VARIANTS_0_ID").unwrap(),
+    )
+    .expect("Invalid UUID");
+    let feature_flag_data_id =
+        uuid::Uuid::parse_str(&std::env::var("FEATURE_FLAG_DATA_ID").unwrap())
+            .expect("Invalid UUID");
+
+    // there is a valid "environment" in the system
+    let environment_data_id = uuid::Uuid::parse_str(&std::env::var("ENVIRONMENT_DATA_ID").unwrap())
+        .expect("Invalid UUID");
+    let body = CreateAllocationsRequest::new(AllocationDataRequest::new(
+        UpsertAllocationRequest::new(
+            "new-targeting-rule-example-feature-flag".to_string(),
+            "New targeting rule Example-Feature-Flag".to_string(),
+            AllocationType::CANARY,
+        )
+        .guardrail_metrics(vec![])
+        .targeting_rules(vec![])
+        .variant_weights(vec![VariantWeightRequest::new(100.0)
+            .variant_id(feature_flag_data_attributes_variants_0_id.clone())]),
+        AllocationDataType::ALLOCATIONS,
+    ));
+    let configuration = datadog::Configuration::new();
+    let api = FeatureFlagsAPI::with_config(configuration);
+    let resp = api
+        .create_allocations_for_feature_flag_in_environment(
+            feature_flag_data_id.clone(),
+            environment_data_id.clone(),
+            body,
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_feature-flags_CreateAllocationsForFeatureFlagInEnvironment_3662093014.rs

@@ -0,0 +1,20 @@
+// Pause a progressive rollout returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_feature_flags::FeatureFlagsAPI;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() {
+    let configuration = datadog::Configuration::new();
+    let api = FeatureFlagsAPI::with_config(configuration);
+    let resp = api
+        .pause_exposure_schedule(
+            Uuid::parse_str("550e8400-e29b-41d4-a716-446655440010").expect("invalid UUID"),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_feature-flags_PauseExposureSchedule.rs

@@ -0,0 +1,21 @@
+// Pause an exposure schedule returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_feature_flags::FeatureFlagsAPI;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "exposure_schedule" in the system
+    let exposure_schedule_id =
+        uuid::Uuid::parse_str(&std::env::var("EXPOSURE_SCHEDULE_ID").unwrap())
+            .expect("Invalid UUID");
+    let configuration = datadog::Configuration::new();
+    let api = FeatureFlagsAPI::with_config(configuration);
+    let resp = api
+        .pause_exposure_schedule(exposure_schedule_id.clone())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_feature-flags_PauseExposureSchedule_3035042230.rs

@@ -0,0 +1,20 @@
+// Resume a progressive rollout returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_feature_flags::FeatureFlagsAPI;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() {
+    let configuration = datadog::Configuration::new();
+    let api = FeatureFlagsAPI::with_config(configuration);
+    let resp = api
+        .resume_exposure_schedule(
+            Uuid::parse_str("550e8400-e29b-41d4-a716-446655440010").expect("invalid UUID"),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_feature-flags_ResumeExposureSchedule.rs

@@ -0,0 +1,20 @@
+// Start a progressive rollout returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_feature_flags::FeatureFlagsAPI;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() {
+    let configuration = datadog::Configuration::new();
+    let api = FeatureFlagsAPI::with_config(configuration);
+    let resp = api
+        .start_exposure_schedule(
+            Uuid::parse_str("550e8400-e29b-41d4-a716-446655440010").expect("invalid UUID"),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_feature-flags_StartExposureSchedule.rs

@@ -0,0 +1,21 @@
+// Start an exposure schedule returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_feature_flags::FeatureFlagsAPI;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "exposure_schedule" in the system
+    let exposure_schedule_id =
+        uuid::Uuid::parse_str(&std::env::var("EXPOSURE_SCHEDULE_ID").unwrap())
+            .expect("Invalid UUID");
+    let configuration = datadog::Configuration::new();
+    let api = FeatureFlagsAPI::with_config(configuration);
+    let resp = api
+        .start_exposure_schedule(exposure_schedule_id.clone())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_feature-flags_StartExposureSchedule_3083014598.rs

@@ -0,0 +1,20 @@
+// Stop a progressive rollout returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_feature_flags::FeatureFlagsAPI;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() {
+    let configuration = datadog::Configuration::new();
+    let api = FeatureFlagsAPI::with_config(configuration);
+    let resp = api
+        .stop_exposure_schedule(
+            Uuid::parse_str("550e8400-e29b-41d4-a716-446655440010").expect("invalid UUID"),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_feature-flags_StopExposureSchedule.rs

@@ -0,0 +1,21 @@
+// Stop an exposure schedule returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_feature_flags::FeatureFlagsAPI;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "exposure_schedule" in the system
+    let exposure_schedule_id =
+        uuid::Uuid::parse_str(&std::env::var("EXPOSURE_SCHEDULE_ID").unwrap())
+            .expect("Invalid UUID");
+    let configuration = datadog::Configuration::new();
+    let api = FeatureFlagsAPI::with_config(configuration);
+    let resp = api
+        .stop_exposure_schedule(exposure_schedule_id.clone())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}