pub fn serialize_structure_crate_input_batch_evaluate_feature_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchEvaluateFeatureInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.requests {
let mut array_2 = object.key("requests").start_array();
for item_3 in var_1 {
{
#[allow(unused_mut)]
let mut object_4 = array_2.value().start_object();
crate::json_ser::serialize_structure_crate_model_evaluation_request(
&mut object_4,
item_3,
)?;
object_4.finish();
}
}
array_2.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_experiment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateExperimentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_5) = &input.description {
object.key("description").string(var_5.as_str());
}
if let Some(var_6) = &input.metric_goals {
let mut array_7 = object.key("metricGoals").start_array();
for item_8 in var_6 {
{
#[allow(unused_mut)]
let mut object_9 = array_7.value().start_object();
crate::json_ser::serialize_structure_crate_model_metric_goal_config(
&mut object_9,
item_8,
)?;
object_9.finish();
}
}
array_7.finish();
}
if let Some(var_10) = &input.name {
object.key("name").string(var_10.as_str());
}
if let Some(var_11) = &input.online_ab_config {
#[allow(unused_mut)]
let mut object_12 = object.key("onlineAbConfig").start_object();
crate::json_ser::serialize_structure_crate_model_online_ab_config(&mut object_12, var_11)?;
object_12.finish();
}
if let Some(var_13) = &input.randomization_salt {
object.key("randomizationSalt").string(var_13.as_str());
}
if let Some(var_14) = &input.sampling_rate {
object.key("samplingRate").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_14).into()),
);
}
if let Some(var_15) = &input.segment {
object.key("segment").string(var_15.as_str());
}
if let Some(var_16) = &input.tags {
#[allow(unused_mut)]
let mut object_17 = object.key("tags").start_object();
for (key_18, value_19) in var_16 {
{
object_17.key(key_18.as_str()).string(value_19.as_str());
}
}
object_17.finish();
}
if let Some(var_20) = &input.treatments {
let mut array_21 = object.key("treatments").start_array();
for item_22 in var_20 {
{
#[allow(unused_mut)]
let mut object_23 = array_21.value().start_object();
crate::json_ser::serialize_structure_crate_model_treatment_config(
&mut object_23,
item_22,
)?;
object_23.finish();
}
}
array_21.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_feature_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFeatureInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_24) = &input.default_variation {
object.key("defaultVariation").string(var_24.as_str());
}
if let Some(var_25) = &input.description {
object.key("description").string(var_25.as_str());
}
if let Some(var_26) = &input.entity_overrides {
#[allow(unused_mut)]
let mut object_27 = object.key("entityOverrides").start_object();
for (key_28, value_29) in var_26 {
{
object_27.key(key_28.as_str()).string(value_29.as_str());
}
}
object_27.finish();
}
if let Some(var_30) = &input.evaluation_strategy {
object.key("evaluationStrategy").string(var_30.as_str());
}
if let Some(var_31) = &input.name {
object.key("name").string(var_31.as_str());
}
if let Some(var_32) = &input.tags {
#[allow(unused_mut)]
let mut object_33 = object.key("tags").start_object();
for (key_34, value_35) in var_32 {
{
object_33.key(key_34.as_str()).string(value_35.as_str());
}
}
object_33.finish();
}
if let Some(var_36) = &input.variations {
let mut array_37 = object.key("variations").start_array();
for item_38 in var_36 {
{
#[allow(unused_mut)]
let mut object_39 = array_37.value().start_object();
crate::json_ser::serialize_structure_crate_model_variation_config(
&mut object_39,
item_38,
)?;
object_39.finish();
}
}
array_37.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_launch_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLaunchInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_40) = &input.description {
object.key("description").string(var_40.as_str());
}
if let Some(var_41) = &input.groups {
let mut array_42 = object.key("groups").start_array();
for item_43 in var_41 {
{
#[allow(unused_mut)]
let mut object_44 = array_42.value().start_object();
crate::json_ser::serialize_structure_crate_model_launch_group_config(
&mut object_44,
item_43,
)?;
object_44.finish();
}
}
array_42.finish();
}
if let Some(var_45) = &input.metric_monitors {
let mut array_46 = object.key("metricMonitors").start_array();
for item_47 in var_45 {
{
#[allow(unused_mut)]
let mut object_48 = array_46.value().start_object();
crate::json_ser::serialize_structure_crate_model_metric_monitor_config(
&mut object_48,
item_47,
)?;
object_48.finish();
}
}
array_46.finish();
}
if let Some(var_49) = &input.name {
object.key("name").string(var_49.as_str());
}
if let Some(var_50) = &input.randomization_salt {
object.key("randomizationSalt").string(var_50.as_str());
}
if let Some(var_51) = &input.scheduled_splits_config {
#[allow(unused_mut)]
let mut object_52 = object.key("scheduledSplitsConfig").start_object();
crate::json_ser::serialize_structure_crate_model_scheduled_splits_launch_config(
&mut object_52,
var_51,
)?;
object_52.finish();
}
if let Some(var_53) = &input.tags {
#[allow(unused_mut)]
let mut object_54 = object.key("tags").start_object();
for (key_55, value_56) in var_53 {
{
object_54.key(key_55.as_str()).string(value_56.as_str());
}
}
object_54.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_project_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateProjectInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_57) = &input.app_config_resource {
#[allow(unused_mut)]
let mut object_58 = object.key("appConfigResource").start_object();
crate::json_ser::serialize_structure_crate_model_project_app_config_resource_config(
&mut object_58,
var_57,
)?;
object_58.finish();
}
if let Some(var_59) = &input.data_delivery {
#[allow(unused_mut)]
let mut object_60 = object.key("dataDelivery").start_object();
crate::json_ser::serialize_structure_crate_model_project_data_delivery_config(
&mut object_60,
var_59,
)?;
object_60.finish();
}
if let Some(var_61) = &input.description {
object.key("description").string(var_61.as_str());
}
if let Some(var_62) = &input.name {
object.key("name").string(var_62.as_str());
}
if let Some(var_63) = &input.tags {
#[allow(unused_mut)]
let mut object_64 = object.key("tags").start_object();
for (key_65, value_66) in var_63 {
{
object_64.key(key_65.as_str()).string(value_66.as_str());
}
}
object_64.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_segment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSegmentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_67) = &input.description {
object.key("description").string(var_67.as_str());
}
if let Some(var_68) = &input.name {
object.key("name").string(var_68.as_str());
}
if let Some(var_69) = &input.pattern {
object.key("pattern").string(var_69.as_str());
}
if let Some(var_70) = &input.tags {
#[allow(unused_mut)]
let mut object_71 = object.key("tags").start_object();
for (key_72, value_73) in var_70 {
{
object_71.key(key_72.as_str()).string(value_73.as_str());
}
}
object_71.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_evaluate_feature_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::EvaluateFeatureInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_74) = &input.entity_id {
object.key("entityId").string(var_74.as_str());
}
if let Some(var_75) = &input.evaluation_context {
object.key("evaluationContext").string(var_75.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_experiment_results_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetExperimentResultsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_76) = &input.base_stat {
object.key("baseStat").string(var_76.as_str());
}
if let Some(var_77) = &input.end_time {
object
.key("endTime")
.date_time(var_77, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_78) = &input.metric_names {
let mut array_79 = object.key("metricNames").start_array();
for item_80 in var_78 {
{
array_79.value().string(item_80.as_str());
}
}
array_79.finish();
}
if input.period != 0 {
object.key("period").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.period).into()),
);
}
if let Some(var_81) = &input.report_names {
let mut array_82 = object.key("reportNames").start_array();
for item_83 in var_81 {
{
array_82.value().string(item_83.as_str());
}
}
array_82.finish();
}
if let Some(var_84) = &input.result_stats {
let mut array_85 = object.key("resultStats").start_array();
for item_86 in var_84 {
{
array_85.value().string(item_86.as_str());
}
}
array_85.finish();
}
if let Some(var_87) = &input.start_time {
object
.key("startTime")
.date_time(var_87, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_88) = &input.treatment_names {
let mut array_89 = object.key("treatmentNames").start_array();
for item_90 in var_88 {
{
array_89.value().string(item_90.as_str());
}
}
array_89.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_project_events_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutProjectEventsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_91) = &input.events {
let mut array_92 = object.key("events").start_array();
for item_93 in var_91 {
{
#[allow(unused_mut)]
let mut object_94 = array_92.value().start_object();
crate::json_ser::serialize_structure_crate_model_event(&mut object_94, item_93)?;
object_94.finish();
}
}
array_92.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_experiment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartExperimentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_95) = &input.analysis_complete_time {
object
.key("analysisCompleteTime")
.date_time(var_95, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_experiment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopExperimentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_96) = &input.desired_state {
object.key("desiredState").string(var_96.as_str());
}
if let Some(var_97) = &input.reason {
object.key("reason").string(var_97.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_launch_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopLaunchInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_98) = &input.desired_state {
object.key("desiredState").string(var_98.as_str());
}
if let Some(var_99) = &input.reason {
object.key("reason").string(var_99.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_100) = &input.tags {
#[allow(unused_mut)]
let mut object_101 = object.key("tags").start_object();
for (key_102, value_103) in var_100 {
{
object_101.key(key_102.as_str()).string(value_103.as_str());
}
}
object_101.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_test_segment_pattern_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TestSegmentPatternInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_104) = &input.pattern {
object.key("pattern").string(var_104.as_str());
}
if let Some(var_105) = &input.payload {
object.key("payload").string(var_105.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_experiment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateExperimentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_106) = &input.description {
object.key("description").string(var_106.as_str());
}
if let Some(var_107) = &input.metric_goals {
let mut array_108 = object.key("metricGoals").start_array();
for item_109 in var_107 {
{
#[allow(unused_mut)]
let mut object_110 = array_108.value().start_object();
crate::json_ser::serialize_structure_crate_model_metric_goal_config(
&mut object_110,
item_109,
)?;
object_110.finish();
}
}
array_108.finish();
}
if let Some(var_111) = &input.online_ab_config {
#[allow(unused_mut)]
let mut object_112 = object.key("onlineAbConfig").start_object();
crate::json_ser::serialize_structure_crate_model_online_ab_config(
&mut object_112,
var_111,
)?;
object_112.finish();
}
if let Some(var_113) = &input.randomization_salt {
object.key("randomizationSalt").string(var_113.as_str());
}
if input.remove_segment {
object.key("removeSegment").boolean(input.remove_segment);
}
if let Some(var_114) = &input.sampling_rate {
object.key("samplingRate").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_114).into()),
);
}
if let Some(var_115) = &input.segment {
object.key("segment").string(var_115.as_str());
}
if let Some(var_116) = &input.treatments {
let mut array_117 = object.key("treatments").start_array();
for item_118 in var_116 {
{
#[allow(unused_mut)]
let mut object_119 = array_117.value().start_object();
crate::json_ser::serialize_structure_crate_model_treatment_config(
&mut object_119,
item_118,
)?;
object_119.finish();
}
}
array_117.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_feature_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFeatureInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_120) = &input.add_or_update_variations {
let mut array_121 = object.key("addOrUpdateVariations").start_array();
for item_122 in var_120 {
{
#[allow(unused_mut)]
let mut object_123 = array_121.value().start_object();
crate::json_ser::serialize_structure_crate_model_variation_config(
&mut object_123,
item_122,
)?;
object_123.finish();
}
}
array_121.finish();
}
if let Some(var_124) = &input.default_variation {
object.key("defaultVariation").string(var_124.as_str());
}
if let Some(var_125) = &input.description {
object.key("description").string(var_125.as_str());
}
if let Some(var_126) = &input.entity_overrides {
#[allow(unused_mut)]
let mut object_127 = object.key("entityOverrides").start_object();
for (key_128, value_129) in var_126 {
{
object_127.key(key_128.as_str()).string(value_129.as_str());
}
}
object_127.finish();
}
if let Some(var_130) = &input.evaluation_strategy {
object.key("evaluationStrategy").string(var_130.as_str());
}
if let Some(var_131) = &input.remove_variations {
let mut array_132 = object.key("removeVariations").start_array();
for item_133 in var_131 {
{
array_132.value().string(item_133.as_str());
}
}
array_132.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_launch_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateLaunchInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_134) = &input.description {
object.key("description").string(var_134.as_str());
}
if let Some(var_135) = &input.groups {
let mut array_136 = object.key("groups").start_array();
for item_137 in var_135 {
{
#[allow(unused_mut)]
let mut object_138 = array_136.value().start_object();
crate::json_ser::serialize_structure_crate_model_launch_group_config(
&mut object_138,
item_137,
)?;
object_138.finish();
}
}
array_136.finish();
}
if let Some(var_139) = &input.metric_monitors {
let mut array_140 = object.key("metricMonitors").start_array();
for item_141 in var_139 {
{
#[allow(unused_mut)]
let mut object_142 = array_140.value().start_object();
crate::json_ser::serialize_structure_crate_model_metric_monitor_config(
&mut object_142,
item_141,
)?;
object_142.finish();
}
}
array_140.finish();
}
if let Some(var_143) = &input.randomization_salt {
object.key("randomizationSalt").string(var_143.as_str());
}
if let Some(var_144) = &input.scheduled_splits_config {
#[allow(unused_mut)]
let mut object_145 = object.key("scheduledSplitsConfig").start_object();
crate::json_ser::serialize_structure_crate_model_scheduled_splits_launch_config(
&mut object_145,
var_144,
)?;
object_145.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_project_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateProjectInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_146) = &input.app_config_resource {
#[allow(unused_mut)]
let mut object_147 = object.key("appConfigResource").start_object();
crate::json_ser::serialize_structure_crate_model_project_app_config_resource_config(
&mut object_147,
var_146,
)?;
object_147.finish();
}
if let Some(var_148) = &input.description {
object.key("description").string(var_148.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_project_data_delivery_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateProjectDataDeliveryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_149) = &input.cloud_watch_logs {
#[allow(unused_mut)]
let mut object_150 = object.key("cloudWatchLogs").start_object();
crate::json_ser::serialize_structure_crate_model_cloud_watch_logs_destination_config(
&mut object_150,
var_149,
)?;
object_150.finish();
}
if let Some(var_151) = &input.s3_destination {
#[allow(unused_mut)]
let mut object_152 = object.key("s3Destination").start_object();
crate::json_ser::serialize_structure_crate_model_s3_destination_config(
&mut object_152,
var_151,
)?;
object_152.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_evaluation_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EvaluationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_153) = &input.feature {
object.key("feature").string(var_153.as_str());
}
if let Some(var_154) = &input.entity_id {
object.key("entityId").string(var_154.as_str());
}
if let Some(var_155) = &input.evaluation_context {
object.key("evaluationContext").string(var_155.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_metric_goal_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MetricGoalConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_156) = &input.metric_definition {
#[allow(unused_mut)]
let mut object_157 = object.key("metricDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_metric_definition_config(
&mut object_157,
var_156,
)?;
object_157.finish();
}
if let Some(var_158) = &input.desired_change {
object.key("desiredChange").string(var_158.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_online_ab_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OnlineAbConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_159) = &input.control_treatment_name {
object.key("controlTreatmentName").string(var_159.as_str());
}
if let Some(var_160) = &input.treatment_weights {
#[allow(unused_mut)]
let mut object_161 = object.key("treatmentWeights").start_object();
for (key_162, value_163) in var_160 {
{
object_161.key(key_162.as_str()).number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*value_163).into()),
);
}
}
object_161.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_treatment_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TreatmentConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_164) = &input.name {
object.key("name").string(var_164.as_str());
}
if let Some(var_165) = &input.description {
object.key("description").string(var_165.as_str());
}
if let Some(var_166) = &input.feature {
object.key("feature").string(var_166.as_str());
}
if let Some(var_167) = &input.variation {
object.key("variation").string(var_167.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_variation_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VariationConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_168) = &input.name {
object.key("name").string(var_168.as_str());
}
if let Some(var_169) = &input.value {
#[allow(unused_mut)]
let mut object_170 = object.key("value").start_object();
crate::json_ser::serialize_union_crate_model_variable_value(&mut object_170, var_169)?;
object_170.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_launch_group_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LaunchGroupConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_171) = &input.name {
object.key("name").string(var_171.as_str());
}
if let Some(var_172) = &input.description {
object.key("description").string(var_172.as_str());
}
if let Some(var_173) = &input.feature {
object.key("feature").string(var_173.as_str());
}
if let Some(var_174) = &input.variation {
object.key("variation").string(var_174.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_metric_monitor_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MetricMonitorConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_175) = &input.metric_definition {
#[allow(unused_mut)]
let mut object_176 = object.key("metricDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_metric_definition_config(
&mut object_176,
var_175,
)?;
object_176.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_scheduled_splits_launch_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ScheduledSplitsLaunchConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_177) = &input.steps {
let mut array_178 = object.key("steps").start_array();
for item_179 in var_177 {
{
#[allow(unused_mut)]
let mut object_180 = array_178.value().start_object();
crate::json_ser::serialize_structure_crate_model_scheduled_split_config(
&mut object_180,
item_179,
)?;
object_180.finish();
}
}
array_178.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_project_app_config_resource_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProjectAppConfigResourceConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_181) = &input.application_id {
object.key("applicationId").string(var_181.as_str());
}
if let Some(var_182) = &input.environment_id {
object.key("environmentId").string(var_182.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_project_data_delivery_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProjectDataDeliveryConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_183) = &input.s3_destination {
#[allow(unused_mut)]
let mut object_184 = object.key("s3Destination").start_object();
crate::json_ser::serialize_structure_crate_model_s3_destination_config(
&mut object_184,
var_183,
)?;
object_184.finish();
}
if let Some(var_185) = &input.cloud_watch_logs {
#[allow(unused_mut)]
let mut object_186 = object.key("cloudWatchLogs").start_object();
crate::json_ser::serialize_structure_crate_model_cloud_watch_logs_destination_config(
&mut object_186,
var_185,
)?;
object_186.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_event(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Event,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_187) = &input.timestamp {
object
.key("timestamp")
.date_time(var_187, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_188) = &input.r#type {
object.key("type").string(var_188.as_str());
}
if let Some(var_189) = &input.data {
object.key("data").string(var_189.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_cloud_watch_logs_destination_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CloudWatchLogsDestinationConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_190) = &input.log_group {
object.key("logGroup").string(var_190.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_destination_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3DestinationConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_191) = &input.bucket {
object.key("bucket").string(var_191.as_str());
}
if let Some(var_192) = &input.prefix {
object.key("prefix").string(var_192.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_metric_definition_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MetricDefinitionConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_193) = &input.name {
object.key("name").string(var_193.as_str());
}
if let Some(var_194) = &input.entity_id_key {
object.key("entityIdKey").string(var_194.as_str());
}
if let Some(var_195) = &input.value_key {
object.key("valueKey").string(var_195.as_str());
}
if let Some(var_196) = &input.event_pattern {
object.key("eventPattern").string(var_196.as_str());
}
if let Some(var_197) = &input.unit_label {
object.key("unitLabel").string(var_197.as_str());
}
Ok(())
}
pub fn serialize_union_crate_model_variable_value(
object_170: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VariableValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::VariableValue::BoolValue(inner) => {
object_170.key("boolValue").boolean(*inner);
}
crate::model::VariableValue::StringValue(inner) => {
object_170.key("stringValue").string(inner.as_str());
}
crate::model::VariableValue::LongValue(inner) => {
object_170.key("longValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*inner).into()),
);
}
crate::model::VariableValue::DoubleValue(inner) => {
object_170.key("doubleValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*inner).into()),
);
}
crate::model::VariableValue::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"VariableValue",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_scheduled_split_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ScheduledSplitConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_198) = &input.start_time {
object
.key("startTime")
.date_time(var_198, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_199) = &input.group_weights {
#[allow(unused_mut)]
let mut object_200 = object.key("groupWeights").start_object();
for (key_201, value_202) in var_199 {
{
object_200.key(key_201.as_str()).number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*value_202).into()),
);
}
}
object_200.finish();
}
if let Some(var_203) = &input.segment_overrides {
let mut array_204 = object.key("segmentOverrides").start_array();
for item_205 in var_203 {
{
#[allow(unused_mut)]
let mut object_206 = array_204.value().start_object();
crate::json_ser::serialize_structure_crate_model_segment_override(
&mut object_206,
item_205,
)?;
object_206.finish();
}
}
array_204.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_segment_override(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SegmentOverride,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_207) = &input.segment {
object.key("segment").string(var_207.as_str());
}
if let Some(var_208) = &input.evaluation_order {
object.key("evaluationOrder").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_208).into()),
);
}
if let Some(var_209) = &input.weights {
#[allow(unused_mut)]
let mut object_210 = object.key("weights").start_object();
for (key_211, value_212) in var_209 {
{
object_210.key(key_211.as_str()).number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*value_212).into()),
);
}
}
object_210.finish();
}
Ok(())
}