pub fn serialize_structure_crate_model_create_application_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateApplicationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.name {
object.key("Name").string(var_1.as_str());
}
if let Some(var_2) = &input.tags {
#[allow(unused_mut)]
let mut object_3 = object.key("tags").start_object();
for (key_4, value_5) in var_2 {
{
object_3.key(key_4.as_str()).string(value_5.as_str());
}
}
object_3.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_write_campaign_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WriteCampaignRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_6) = &input.additional_treatments {
let mut array_7 = object.key("AdditionalTreatments").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_write_treatment_resource(
&mut object_9,
item_8,
)?;
object_9.finish();
}
}
array_7.finish();
}
if let Some(var_10) = &input.custom_delivery_configuration {
#[allow(unused_mut)]
let mut object_11 = object.key("CustomDeliveryConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_custom_delivery_configuration(
&mut object_11,
var_10,
)?;
object_11.finish();
}
if let Some(var_12) = &input.description {
object.key("Description").string(var_12.as_str());
}
if input.holdout_percent != 0 {
object.key("HoldoutPercent").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.holdout_percent).into()),
);
}
if let Some(var_13) = &input.hook {
#[allow(unused_mut)]
let mut object_14 = object.key("Hook").start_object();
crate::json_ser::serialize_structure_crate_model_campaign_hook(&mut object_14, var_13)?;
object_14.finish();
}
if input.is_paused {
object.key("IsPaused").boolean(input.is_paused);
}
if let Some(var_15) = &input.limits {
#[allow(unused_mut)]
let mut object_16 = object.key("Limits").start_object();
crate::json_ser::serialize_structure_crate_model_campaign_limits(&mut object_16, var_15)?;
object_16.finish();
}
if let Some(var_17) = &input.message_configuration {
#[allow(unused_mut)]
let mut object_18 = object.key("MessageConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_message_configuration(
&mut object_18,
var_17,
)?;
object_18.finish();
}
if let Some(var_19) = &input.name {
object.key("Name").string(var_19.as_str());
}
if let Some(var_20) = &input.schedule {
#[allow(unused_mut)]
let mut object_21 = object.key("Schedule").start_object();
crate::json_ser::serialize_structure_crate_model_schedule(&mut object_21, var_20)?;
object_21.finish();
}
if let Some(var_22) = &input.segment_id {
object.key("SegmentId").string(var_22.as_str());
}
if input.segment_version != 0 {
object.key("SegmentVersion").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.segment_version).into()),
);
}
if let Some(var_23) = &input.tags {
#[allow(unused_mut)]
let mut object_24 = object.key("tags").start_object();
for (key_25, value_26) in var_23 {
{
object_24.key(key_25.as_str()).string(value_26.as_str());
}
}
object_24.finish();
}
if let Some(var_27) = &input.template_configuration {
#[allow(unused_mut)]
let mut object_28 = object.key("TemplateConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_template_configuration(
&mut object_28,
var_27,
)?;
object_28.finish();
}
if let Some(var_29) = &input.treatment_description {
object.key("TreatmentDescription").string(var_29.as_str());
}
if let Some(var_30) = &input.treatment_name {
object.key("TreatmentName").string(var_30.as_str());
}
if input.priority != 0 {
object.key("Priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.priority).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_email_template_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EmailTemplateRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_31) = &input.default_substitutions {
object.key("DefaultSubstitutions").string(var_31.as_str());
}
if let Some(var_32) = &input.html_part {
object.key("HtmlPart").string(var_32.as_str());
}
if let Some(var_33) = &input.recommender_id {
object.key("RecommenderId").string(var_33.as_str());
}
if let Some(var_34) = &input.subject {
object.key("Subject").string(var_34.as_str());
}
if let Some(var_35) = &input.tags {
#[allow(unused_mut)]
let mut object_36 = object.key("tags").start_object();
for (key_37, value_38) in var_35 {
{
object_36.key(key_37.as_str()).string(value_38.as_str());
}
}
object_36.finish();
}
if let Some(var_39) = &input.template_description {
object.key("TemplateDescription").string(var_39.as_str());
}
if let Some(var_40) = &input.text_part {
object.key("TextPart").string(var_40.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_export_job_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExportJobRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_41) = &input.role_arn {
object.key("RoleArn").string(var_41.as_str());
}
if let Some(var_42) = &input.s3_url_prefix {
object.key("S3UrlPrefix").string(var_42.as_str());
}
if let Some(var_43) = &input.segment_id {
object.key("SegmentId").string(var_43.as_str());
}
if input.segment_version != 0 {
object.key("SegmentVersion").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.segment_version).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_import_job_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ImportJobRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.define_segment {
object.key("DefineSegment").boolean(input.define_segment);
}
if let Some(var_44) = &input.external_id {
object.key("ExternalId").string(var_44.as_str());
}
if let Some(var_45) = &input.format {
object.key("Format").string(var_45.as_str());
}
if input.register_endpoints {
object
.key("RegisterEndpoints")
.boolean(input.register_endpoints);
}
if let Some(var_46) = &input.role_arn {
object.key("RoleArn").string(var_46.as_str());
}
if let Some(var_47) = &input.s3_url {
object.key("S3Url").string(var_47.as_str());
}
if let Some(var_48) = &input.segment_id {
object.key("SegmentId").string(var_48.as_str());
}
if let Some(var_49) = &input.segment_name {
object.key("SegmentName").string(var_49.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_in_app_template_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InAppTemplateRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_50) = &input.content {
let mut array_51 = object.key("Content").start_array();
for item_52 in var_50 {
{
#[allow(unused_mut)]
let mut object_53 = array_51.value().start_object();
crate::json_ser::serialize_structure_crate_model_in_app_message_content(
&mut object_53,
item_52,
)?;
object_53.finish();
}
}
array_51.finish();
}
if let Some(var_54) = &input.custom_config {
#[allow(unused_mut)]
let mut object_55 = object.key("CustomConfig").start_object();
for (key_56, value_57) in var_54 {
{
object_55.key(key_56.as_str()).string(value_57.as_str());
}
}
object_55.finish();
}
if let Some(var_58) = &input.layout {
object.key("Layout").string(var_58.as_str());
}
if let Some(var_59) = &input.tags {
#[allow(unused_mut)]
let mut object_60 = object.key("tags").start_object();
for (key_61, value_62) in var_59 {
{
object_60.key(key_61.as_str()).string(value_62.as_str());
}
}
object_60.finish();
}
if let Some(var_63) = &input.template_description {
object.key("TemplateDescription").string(var_63.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_write_journey_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WriteJourneyRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_64) = &input.activities {
#[allow(unused_mut)]
let mut object_65 = object.key("Activities").start_object();
for (key_66, value_67) in var_64 {
{
#[allow(unused_mut)]
let mut object_68 = object_65.key(key_66.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_activity(
&mut object_68,
value_67,
)?;
object_68.finish();
}
}
object_65.finish();
}
if let Some(var_69) = &input.creation_date {
object.key("CreationDate").string(var_69.as_str());
}
if let Some(var_70) = &input.last_modified_date {
object.key("LastModifiedDate").string(var_70.as_str());
}
if let Some(var_71) = &input.limits {
#[allow(unused_mut)]
let mut object_72 = object.key("Limits").start_object();
crate::json_ser::serialize_structure_crate_model_journey_limits(&mut object_72, var_71)?;
object_72.finish();
}
if input.local_time {
object.key("LocalTime").boolean(input.local_time);
}
if let Some(var_73) = &input.name {
object.key("Name").string(var_73.as_str());
}
if let Some(var_74) = &input.quiet_time {
#[allow(unused_mut)]
let mut object_75 = object.key("QuietTime").start_object();
crate::json_ser::serialize_structure_crate_model_quiet_time(&mut object_75, var_74)?;
object_75.finish();
}
if let Some(var_76) = &input.refresh_frequency {
object.key("RefreshFrequency").string(var_76.as_str());
}
if let Some(var_77) = &input.schedule {
#[allow(unused_mut)]
let mut object_78 = object.key("Schedule").start_object();
crate::json_ser::serialize_structure_crate_model_journey_schedule(&mut object_78, var_77)?;
object_78.finish();
}
if let Some(var_79) = &input.start_activity {
object.key("StartActivity").string(var_79.as_str());
}
if let Some(var_80) = &input.start_condition {
#[allow(unused_mut)]
let mut object_81 = object.key("StartCondition").start_object();
crate::json_ser::serialize_structure_crate_model_start_condition(&mut object_81, var_80)?;
object_81.finish();
}
if let Some(var_82) = &input.state {
object.key("State").string(var_82.as_str());
}
if input.wait_for_quiet_time {
object
.key("WaitForQuietTime")
.boolean(input.wait_for_quiet_time);
}
if input.refresh_on_segment_update {
object
.key("RefreshOnSegmentUpdate")
.boolean(input.refresh_on_segment_update);
}
if let Some(var_83) = &input.journey_channel_settings {
#[allow(unused_mut)]
let mut object_84 = object.key("JourneyChannelSettings").start_object();
crate::json_ser::serialize_structure_crate_model_journey_channel_settings(
&mut object_84,
var_83,
)?;
object_84.finish();
}
if input.sending_schedule {
object
.key("SendingSchedule")
.boolean(input.sending_schedule);
}
if let Some(var_85) = &input.open_hours {
#[allow(unused_mut)]
let mut object_86 = object.key("OpenHours").start_object();
crate::json_ser::serialize_structure_crate_model_open_hours(&mut object_86, var_85)?;
object_86.finish();
}
if let Some(var_87) = &input.closed_days {
#[allow(unused_mut)]
let mut object_88 = object.key("ClosedDays").start_object();
crate::json_ser::serialize_structure_crate_model_closed_days(&mut object_88, var_87)?;
object_88.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_push_notification_template_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PushNotificationTemplateRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_89) = &input.adm {
#[allow(unused_mut)]
let mut object_90 = object.key("ADM").start_object();
crate::json_ser::serialize_structure_crate_model_android_push_notification_template(
&mut object_90,
var_89,
)?;
object_90.finish();
}
if let Some(var_91) = &input.apns {
#[allow(unused_mut)]
let mut object_92 = object.key("APNS").start_object();
crate::json_ser::serialize_structure_crate_model_apns_push_notification_template(
&mut object_92,
var_91,
)?;
object_92.finish();
}
if let Some(var_93) = &input.baidu {
#[allow(unused_mut)]
let mut object_94 = object.key("Baidu").start_object();
crate::json_ser::serialize_structure_crate_model_android_push_notification_template(
&mut object_94,
var_93,
)?;
object_94.finish();
}
if let Some(var_95) = &input.default_value {
#[allow(unused_mut)]
let mut object_96 = object.key("Default").start_object();
crate::json_ser::serialize_structure_crate_model_default_push_notification_template(
&mut object_96,
var_95,
)?;
object_96.finish();
}
if let Some(var_97) = &input.default_substitutions {
object.key("DefaultSubstitutions").string(var_97.as_str());
}
if let Some(var_98) = &input.gcm {
#[allow(unused_mut)]
let mut object_99 = object.key("GCM").start_object();
crate::json_ser::serialize_structure_crate_model_android_push_notification_template(
&mut object_99,
var_98,
)?;
object_99.finish();
}
if let Some(var_100) = &input.recommender_id {
object.key("RecommenderId").string(var_100.as_str());
}
if let Some(var_101) = &input.tags {
#[allow(unused_mut)]
let mut object_102 = object.key("tags").start_object();
for (key_103, value_104) in var_101 {
{
object_102.key(key_103.as_str()).string(value_104.as_str());
}
}
object_102.finish();
}
if let Some(var_105) = &input.template_description {
object.key("TemplateDescription").string(var_105.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_create_recommender_configuration_shape(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateRecommenderConfigurationShape,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_106) = &input.attributes {
#[allow(unused_mut)]
let mut object_107 = object.key("Attributes").start_object();
for (key_108, value_109) in var_106 {
{
object_107.key(key_108.as_str()).string(value_109.as_str());
}
}
object_107.finish();
}
if let Some(var_110) = &input.description {
object.key("Description").string(var_110.as_str());
}
if let Some(var_111) = &input.name {
object.key("Name").string(var_111.as_str());
}
if let Some(var_112) = &input.recommendation_provider_id_type {
object
.key("RecommendationProviderIdType")
.string(var_112.as_str());
}
if let Some(var_113) = &input.recommendation_provider_role_arn {
object
.key("RecommendationProviderRoleArn")
.string(var_113.as_str());
}
if let Some(var_114) = &input.recommendation_provider_uri {
object
.key("RecommendationProviderUri")
.string(var_114.as_str());
}
if let Some(var_115) = &input.recommendation_transformer_uri {
object
.key("RecommendationTransformerUri")
.string(var_115.as_str());
}
if let Some(var_116) = &input.recommendations_display_name {
object
.key("RecommendationsDisplayName")
.string(var_116.as_str());
}
if input.recommendations_per_message != 0 {
object.key("RecommendationsPerMessage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.recommendations_per_message).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_write_segment_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WriteSegmentRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_117) = &input.dimensions {
#[allow(unused_mut)]
let mut object_118 = object.key("Dimensions").start_object();
crate::json_ser::serialize_structure_crate_model_segment_dimensions(
&mut object_118,
var_117,
)?;
object_118.finish();
}
if let Some(var_119) = &input.name {
object.key("Name").string(var_119.as_str());
}
if let Some(var_120) = &input.segment_groups {
#[allow(unused_mut)]
let mut object_121 = object.key("SegmentGroups").start_object();
crate::json_ser::serialize_structure_crate_model_segment_group_list(
&mut object_121,
var_120,
)?;
object_121.finish();
}
if let Some(var_122) = &input.tags {
#[allow(unused_mut)]
let mut object_123 = object.key("tags").start_object();
for (key_124, value_125) in var_122 {
{
object_123.key(key_124.as_str()).string(value_125.as_str());
}
}
object_123.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sms_template_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SmsTemplateRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_126) = &input.body {
object.key("Body").string(var_126.as_str());
}
if let Some(var_127) = &input.default_substitutions {
object.key("DefaultSubstitutions").string(var_127.as_str());
}
if let Some(var_128) = &input.recommender_id {
object.key("RecommenderId").string(var_128.as_str());
}
if let Some(var_129) = &input.tags {
#[allow(unused_mut)]
let mut object_130 = object.key("tags").start_object();
for (key_131, value_132) in var_129 {
{
object_130.key(key_131.as_str()).string(value_132.as_str());
}
}
object_130.finish();
}
if let Some(var_133) = &input.template_description {
object.key("TemplateDescription").string(var_133.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_voice_template_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VoiceTemplateRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_134) = &input.body {
object.key("Body").string(var_134.as_str());
}
if let Some(var_135) = &input.default_substitutions {
object.key("DefaultSubstitutions").string(var_135.as_str());
}
if let Some(var_136) = &input.language_code {
object.key("LanguageCode").string(var_136.as_str());
}
if let Some(var_137) = &input.tags {
#[allow(unused_mut)]
let mut object_138 = object.key("tags").start_object();
for (key_139, value_140) in var_137 {
{
object_138.key(key_139.as_str()).string(value_140.as_str());
}
}
object_138.finish();
}
if let Some(var_141) = &input.template_description {
object.key("TemplateDescription").string(var_141.as_str());
}
if let Some(var_142) = &input.voice_id {
object.key("VoiceId").string(var_142.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_number_validate_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NumberValidateRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_143) = &input.iso_country_code {
object.key("IsoCountryCode").string(var_143.as_str());
}
if let Some(var_144) = &input.phone_number {
object.key("PhoneNumber").string(var_144.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_events_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EventsRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_145) = &input.batch_item {
#[allow(unused_mut)]
let mut object_146 = object.key("BatchItem").start_object();
for (key_147, value_148) in var_145 {
{
#[allow(unused_mut)]
let mut object_149 = object_146.key(key_147.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_events_batch(
&mut object_149,
value_148,
)?;
object_149.finish();
}
}
object_146.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_write_event_stream(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WriteEventStream,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_150) = &input.destination_stream_arn {
object.key("DestinationStreamArn").string(var_150.as_str());
}
if let Some(var_151) = &input.role_arn {
object.key("RoleArn").string(var_151.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_update_attributes_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateAttributesRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_152) = &input.blacklist {
let mut array_153 = object.key("Blacklist").start_array();
for item_154 in var_152 {
{
array_153.value().string(item_154.as_str());
}
}
array_153.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_message_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MessageRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_155) = &input.addresses {
#[allow(unused_mut)]
let mut object_156 = object.key("Addresses").start_object();
for (key_157, value_158) in var_155 {
{
#[allow(unused_mut)]
let mut object_159 = object_156.key(key_157.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_address_configuration(
&mut object_159,
value_158,
)?;
object_159.finish();
}
}
object_156.finish();
}
if let Some(var_160) = &input.context {
#[allow(unused_mut)]
let mut object_161 = object.key("Context").start_object();
for (key_162, value_163) in var_160 {
{
object_161.key(key_162.as_str()).string(value_163.as_str());
}
}
object_161.finish();
}
if let Some(var_164) = &input.endpoints {
#[allow(unused_mut)]
let mut object_165 = object.key("Endpoints").start_object();
for (key_166, value_167) in var_164 {
{
#[allow(unused_mut)]
let mut object_168 = object_165.key(key_166.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_send_configuration(
&mut object_168,
value_167,
)?;
object_168.finish();
}
}
object_165.finish();
}
if let Some(var_169) = &input.message_configuration {
#[allow(unused_mut)]
let mut object_170 = object.key("MessageConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_direct_message_configuration(
&mut object_170,
var_169,
)?;
object_170.finish();
}
if let Some(var_171) = &input.template_configuration {
#[allow(unused_mut)]
let mut object_172 = object.key("TemplateConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_template_configuration(
&mut object_172,
var_171,
)?;
object_172.finish();
}
if let Some(var_173) = &input.trace_id {
object.key("TraceId").string(var_173.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_send_otp_message_request_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SendOtpMessageRequestParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.allowed_attempts != 0 {
object.key("AllowedAttempts").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.allowed_attempts).into()),
);
}
if let Some(var_174) = &input.brand_name {
object.key("BrandName").string(var_174.as_str());
}
if let Some(var_175) = &input.channel {
object.key("Channel").string(var_175.as_str());
}
if input.code_length != 0 {
object.key("CodeLength").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.code_length).into()),
);
}
if let Some(var_176) = &input.destination_identity {
object.key("DestinationIdentity").string(var_176.as_str());
}
if let Some(var_177) = &input.entity_id {
object.key("EntityId").string(var_177.as_str());
}
if let Some(var_178) = &input.language {
object.key("Language").string(var_178.as_str());
}
if let Some(var_179) = &input.origination_identity {
object.key("OriginationIdentity").string(var_179.as_str());
}
if let Some(var_180) = &input.reference_id {
object.key("ReferenceId").string(var_180.as_str());
}
if let Some(var_181) = &input.template_id {
object.key("TemplateId").string(var_181.as_str());
}
if input.validity_period != 0 {
object.key("ValidityPeriod").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.validity_period).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_send_users_message_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SendUsersMessageRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_182) = &input.context {
#[allow(unused_mut)]
let mut object_183 = object.key("Context").start_object();
for (key_184, value_185) in var_182 {
{
object_183.key(key_184.as_str()).string(value_185.as_str());
}
}
object_183.finish();
}
if let Some(var_186) = &input.message_configuration {
#[allow(unused_mut)]
let mut object_187 = object.key("MessageConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_direct_message_configuration(
&mut object_187,
var_186,
)?;
object_187.finish();
}
if let Some(var_188) = &input.template_configuration {
#[allow(unused_mut)]
let mut object_189 = object.key("TemplateConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_template_configuration(
&mut object_189,
var_188,
)?;
object_189.finish();
}
if let Some(var_190) = &input.trace_id {
object.key("TraceId").string(var_190.as_str());
}
if let Some(var_191) = &input.users {
#[allow(unused_mut)]
let mut object_192 = object.key("Users").start_object();
for (key_193, value_194) in var_191 {
{
#[allow(unused_mut)]
let mut object_195 = object_192.key(key_193.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_send_configuration(
&mut object_195,
value_194,
)?;
object_195.finish();
}
}
object_192.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tags_model(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TagsModel,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_196) = &input.tags {
#[allow(unused_mut)]
let mut object_197 = object.key("tags").start_object();
for (key_198, value_199) in var_196 {
{
object_197.key(key_198.as_str()).string(value_199.as_str());
}
}
object_197.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_adm_channel_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AdmChannelRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_200) = &input.client_id {
object.key("ClientId").string(var_200.as_str());
}
if let Some(var_201) = &input.client_secret {
object.key("ClientSecret").string(var_201.as_str());
}
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
Ok(())
}
pub fn serialize_structure_crate_model_apns_channel_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ApnsChannelRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_202) = &input.bundle_id {
object.key("BundleId").string(var_202.as_str());
}
if let Some(var_203) = &input.certificate {
object.key("Certificate").string(var_203.as_str());
}
if let Some(var_204) = &input.default_authentication_method {
object
.key("DefaultAuthenticationMethod")
.string(var_204.as_str());
}
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_205) = &input.private_key {
object.key("PrivateKey").string(var_205.as_str());
}
if let Some(var_206) = &input.team_id {
object.key("TeamId").string(var_206.as_str());
}
if let Some(var_207) = &input.token_key {
object.key("TokenKey").string(var_207.as_str());
}
if let Some(var_208) = &input.token_key_id {
object.key("TokenKeyId").string(var_208.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_apns_sandbox_channel_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ApnsSandboxChannelRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_209) = &input.bundle_id {
object.key("BundleId").string(var_209.as_str());
}
if let Some(var_210) = &input.certificate {
object.key("Certificate").string(var_210.as_str());
}
if let Some(var_211) = &input.default_authentication_method {
object
.key("DefaultAuthenticationMethod")
.string(var_211.as_str());
}
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_212) = &input.private_key {
object.key("PrivateKey").string(var_212.as_str());
}
if let Some(var_213) = &input.team_id {
object.key("TeamId").string(var_213.as_str());
}
if let Some(var_214) = &input.token_key {
object.key("TokenKey").string(var_214.as_str());
}
if let Some(var_215) = &input.token_key_id {
object.key("TokenKeyId").string(var_215.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_apns_voip_channel_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ApnsVoipChannelRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_216) = &input.bundle_id {
object.key("BundleId").string(var_216.as_str());
}
if let Some(var_217) = &input.certificate {
object.key("Certificate").string(var_217.as_str());
}
if let Some(var_218) = &input.default_authentication_method {
object
.key("DefaultAuthenticationMethod")
.string(var_218.as_str());
}
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_219) = &input.private_key {
object.key("PrivateKey").string(var_219.as_str());
}
if let Some(var_220) = &input.team_id {
object.key("TeamId").string(var_220.as_str());
}
if let Some(var_221) = &input.token_key {
object.key("TokenKey").string(var_221.as_str());
}
if let Some(var_222) = &input.token_key_id {
object.key("TokenKeyId").string(var_222.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_apns_voip_sandbox_channel_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ApnsVoipSandboxChannelRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_223) = &input.bundle_id {
object.key("BundleId").string(var_223.as_str());
}
if let Some(var_224) = &input.certificate {
object.key("Certificate").string(var_224.as_str());
}
if let Some(var_225) = &input.default_authentication_method {
object
.key("DefaultAuthenticationMethod")
.string(var_225.as_str());
}
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_226) = &input.private_key {
object.key("PrivateKey").string(var_226.as_str());
}
if let Some(var_227) = &input.team_id {
object.key("TeamId").string(var_227.as_str());
}
if let Some(var_228) = &input.token_key {
object.key("TokenKey").string(var_228.as_str());
}
if let Some(var_229) = &input.token_key_id {
object.key("TokenKeyId").string(var_229.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_write_application_settings_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WriteApplicationSettingsRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_230) = &input.campaign_hook {
#[allow(unused_mut)]
let mut object_231 = object.key("CampaignHook").start_object();
crate::json_ser::serialize_structure_crate_model_campaign_hook(&mut object_231, var_230)?;
object_231.finish();
}
if input.cloud_watch_metrics_enabled {
object
.key("CloudWatchMetricsEnabled")
.boolean(input.cloud_watch_metrics_enabled);
}
if input.event_tagging_enabled {
object
.key("EventTaggingEnabled")
.boolean(input.event_tagging_enabled);
}
if let Some(var_232) = &input.limits {
#[allow(unused_mut)]
let mut object_233 = object.key("Limits").start_object();
crate::json_ser::serialize_structure_crate_model_campaign_limits(&mut object_233, var_232)?;
object_233.finish();
}
if let Some(var_234) = &input.quiet_time {
#[allow(unused_mut)]
let mut object_235 = object.key("QuietTime").start_object();
crate::json_ser::serialize_structure_crate_model_quiet_time(&mut object_235, var_234)?;
object_235.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_baidu_channel_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BaiduChannelRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_236) = &input.api_key {
object.key("ApiKey").string(var_236.as_str());
}
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_237) = &input.secret_key {
object.key("SecretKey").string(var_237.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_email_channel_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EmailChannelRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_238) = &input.configuration_set {
object.key("ConfigurationSet").string(var_238.as_str());
}
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_239) = &input.from_address {
object.key("FromAddress").string(var_239.as_str());
}
if let Some(var_240) = &input.identity {
object.key("Identity").string(var_240.as_str());
}
if let Some(var_241) = &input.role_arn {
object.key("RoleArn").string(var_241.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_endpoint_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EndpointRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_242) = &input.address {
object.key("Address").string(var_242.as_str());
}
if let Some(var_243) = &input.attributes {
#[allow(unused_mut)]
let mut object_244 = object.key("Attributes").start_object();
for (key_245, value_246) in var_243 {
{
let mut array_247 = object_244.key(key_245.as_str()).start_array();
for item_248 in value_246 {
{
array_247.value().string(item_248.as_str());
}
}
array_247.finish();
}
}
object_244.finish();
}
if let Some(var_249) = &input.channel_type {
object.key("ChannelType").string(var_249.as_str());
}
if let Some(var_250) = &input.demographic {
#[allow(unused_mut)]
let mut object_251 = object.key("Demographic").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_demographic(
&mut object_251,
var_250,
)?;
object_251.finish();
}
if let Some(var_252) = &input.effective_date {
object.key("EffectiveDate").string(var_252.as_str());
}
if let Some(var_253) = &input.endpoint_status {
object.key("EndpointStatus").string(var_253.as_str());
}
if let Some(var_254) = &input.location {
#[allow(unused_mut)]
let mut object_255 = object.key("Location").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_location(
&mut object_255,
var_254,
)?;
object_255.finish();
}
if let Some(var_256) = &input.metrics {
#[allow(unused_mut)]
let mut object_257 = object.key("Metrics").start_object();
for (key_258, value_259) in var_256 {
{
object_257.key(key_258.as_str()).number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*value_259).into()),
);
}
}
object_257.finish();
}
if let Some(var_260) = &input.opt_out {
object.key("OptOut").string(var_260.as_str());
}
if let Some(var_261) = &input.request_id {
object.key("RequestId").string(var_261.as_str());
}
if let Some(var_262) = &input.user {
#[allow(unused_mut)]
let mut object_263 = object.key("User").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_user(&mut object_263, var_262)?;
object_263.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_endpoint_batch_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EndpointBatchRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_264) = &input.item {
let mut array_265 = object.key("Item").start_array();
for item_266 in var_264 {
{
#[allow(unused_mut)]
let mut object_267 = array_265.value().start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_batch_item(
&mut object_267,
item_266,
)?;
object_267.finish();
}
}
array_265.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_gcm_channel_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GcmChannelRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_268) = &input.api_key {
object.key("ApiKey").string(var_268.as_str());
}
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
Ok(())
}
pub fn serialize_structure_crate_model_journey_state_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JourneyStateRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_269) = &input.state {
object.key("State").string(var_269.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_update_recommender_configuration_shape(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateRecommenderConfigurationShape,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_270) = &input.attributes {
#[allow(unused_mut)]
let mut object_271 = object.key("Attributes").start_object();
for (key_272, value_273) in var_270 {
{
object_271.key(key_272.as_str()).string(value_273.as_str());
}
}
object_271.finish();
}
if let Some(var_274) = &input.description {
object.key("Description").string(var_274.as_str());
}
if let Some(var_275) = &input.name {
object.key("Name").string(var_275.as_str());
}
if let Some(var_276) = &input.recommendation_provider_id_type {
object
.key("RecommendationProviderIdType")
.string(var_276.as_str());
}
if let Some(var_277) = &input.recommendation_provider_role_arn {
object
.key("RecommendationProviderRoleArn")
.string(var_277.as_str());
}
if let Some(var_278) = &input.recommendation_provider_uri {
object
.key("RecommendationProviderUri")
.string(var_278.as_str());
}
if let Some(var_279) = &input.recommendation_transformer_uri {
object
.key("RecommendationTransformerUri")
.string(var_279.as_str());
}
if let Some(var_280) = &input.recommendations_display_name {
object
.key("RecommendationsDisplayName")
.string(var_280.as_str());
}
if input.recommendations_per_message != 0 {
object.key("RecommendationsPerMessage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.recommendations_per_message).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_sms_channel_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SmsChannelRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_281) = &input.sender_id {
object.key("SenderId").string(var_281.as_str());
}
if let Some(var_282) = &input.short_code {
object.key("ShortCode").string(var_282.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_template_active_version_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TemplateActiveVersionRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_283) = &input.version {
object.key("Version").string(var_283.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_voice_channel_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VoiceChannelRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
Ok(())
}
pub fn serialize_structure_crate_model_verify_otp_message_request_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VerifyOtpMessageRequestParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_284) = &input.destination_identity {
object.key("DestinationIdentity").string(var_284.as_str());
}
if let Some(var_285) = &input.otp {
object.key("Otp").string(var_285.as_str());
}
if let Some(var_286) = &input.reference_id {
object.key("ReferenceId").string(var_286.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_write_treatment_resource(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WriteTreatmentResource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_287) = &input.custom_delivery_configuration {
#[allow(unused_mut)]
let mut object_288 = object.key("CustomDeliveryConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_custom_delivery_configuration(
&mut object_288,
var_287,
)?;
object_288.finish();
}
if let Some(var_289) = &input.message_configuration {
#[allow(unused_mut)]
let mut object_290 = object.key("MessageConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_message_configuration(
&mut object_290,
var_289,
)?;
object_290.finish();
}
if let Some(var_291) = &input.schedule {
#[allow(unused_mut)]
let mut object_292 = object.key("Schedule").start_object();
crate::json_ser::serialize_structure_crate_model_schedule(&mut object_292, var_291)?;
object_292.finish();
}
{
object.key("SizePercent").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.size_percent).into()),
);
}
if let Some(var_293) = &input.template_configuration {
#[allow(unused_mut)]
let mut object_294 = object.key("TemplateConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_template_configuration(
&mut object_294,
var_293,
)?;
object_294.finish();
}
if let Some(var_295) = &input.treatment_description {
object.key("TreatmentDescription").string(var_295.as_str());
}
if let Some(var_296) = &input.treatment_name {
object.key("TreatmentName").string(var_296.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_delivery_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomDeliveryConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_297) = &input.delivery_uri {
object.key("DeliveryUri").string(var_297.as_str());
}
if let Some(var_298) = &input.endpoint_types {
let mut array_299 = object.key("EndpointTypes").start_array();
for item_300 in var_298 {
{
array_299.value().string(item_300.as_str());
}
}
array_299.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_campaign_hook(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CampaignHook,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_301) = &input.lambda_function_name {
object.key("LambdaFunctionName").string(var_301.as_str());
}
if let Some(var_302) = &input.mode {
object.key("Mode").string(var_302.as_str());
}
if let Some(var_303) = &input.web_url {
object.key("WebUrl").string(var_303.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_campaign_limits(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CampaignLimits,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.daily != 0 {
object.key("Daily").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.daily).into()),
);
}
if input.maximum_duration != 0 {
object.key("MaximumDuration").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.maximum_duration).into()),
);
}
if input.messages_per_second != 0 {
object.key("MessagesPerSecond").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.messages_per_second).into()),
);
}
if input.total != 0 {
object.key("Total").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.total).into()),
);
}
if input.session != 0 {
object.key("Session").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.session).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_message_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MessageConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_304) = &input.adm_message {
#[allow(unused_mut)]
let mut object_305 = object.key("ADMMessage").start_object();
crate::json_ser::serialize_structure_crate_model_message(&mut object_305, var_304)?;
object_305.finish();
}
if let Some(var_306) = &input.apns_message {
#[allow(unused_mut)]
let mut object_307 = object.key("APNSMessage").start_object();
crate::json_ser::serialize_structure_crate_model_message(&mut object_307, var_306)?;
object_307.finish();
}
if let Some(var_308) = &input.baidu_message {
#[allow(unused_mut)]
let mut object_309 = object.key("BaiduMessage").start_object();
crate::json_ser::serialize_structure_crate_model_message(&mut object_309, var_308)?;
object_309.finish();
}
if let Some(var_310) = &input.custom_message {
#[allow(unused_mut)]
let mut object_311 = object.key("CustomMessage").start_object();
crate::json_ser::serialize_structure_crate_model_campaign_custom_message(
&mut object_311,
var_310,
)?;
object_311.finish();
}
if let Some(var_312) = &input.default_message {
#[allow(unused_mut)]
let mut object_313 = object.key("DefaultMessage").start_object();
crate::json_ser::serialize_structure_crate_model_message(&mut object_313, var_312)?;
object_313.finish();
}
if let Some(var_314) = &input.email_message {
#[allow(unused_mut)]
let mut object_315 = object.key("EmailMessage").start_object();
crate::json_ser::serialize_structure_crate_model_campaign_email_message(
&mut object_315,
var_314,
)?;
object_315.finish();
}
if let Some(var_316) = &input.gcm_message {
#[allow(unused_mut)]
let mut object_317 = object.key("GCMMessage").start_object();
crate::json_ser::serialize_structure_crate_model_message(&mut object_317, var_316)?;
object_317.finish();
}
if let Some(var_318) = &input.sms_message {
#[allow(unused_mut)]
let mut object_319 = object.key("SMSMessage").start_object();
crate::json_ser::serialize_structure_crate_model_campaign_sms_message(
&mut object_319,
var_318,
)?;
object_319.finish();
}
if let Some(var_320) = &input.in_app_message {
#[allow(unused_mut)]
let mut object_321 = object.key("InAppMessage").start_object();
crate::json_ser::serialize_structure_crate_model_campaign_in_app_message(
&mut object_321,
var_320,
)?;
object_321.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_schedule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Schedule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_322) = &input.end_time {
object.key("EndTime").string(var_322.as_str());
}
if let Some(var_323) = &input.event_filter {
#[allow(unused_mut)]
let mut object_324 = object.key("EventFilter").start_object();
crate::json_ser::serialize_structure_crate_model_campaign_event_filter(
&mut object_324,
var_323,
)?;
object_324.finish();
}
if let Some(var_325) = &input.frequency {
object.key("Frequency").string(var_325.as_str());
}
if input.is_local_time {
object.key("IsLocalTime").boolean(input.is_local_time);
}
if let Some(var_326) = &input.quiet_time {
#[allow(unused_mut)]
let mut object_327 = object.key("QuietTime").start_object();
crate::json_ser::serialize_structure_crate_model_quiet_time(&mut object_327, var_326)?;
object_327.finish();
}
if let Some(var_328) = &input.start_time {
object.key("StartTime").string(var_328.as_str());
}
if let Some(var_329) = &input.timezone {
object.key("Timezone").string(var_329.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_template_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TemplateConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_330) = &input.email_template {
#[allow(unused_mut)]
let mut object_331 = object.key("EmailTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_template(&mut object_331, var_330)?;
object_331.finish();
}
if let Some(var_332) = &input.push_template {
#[allow(unused_mut)]
let mut object_333 = object.key("PushTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_template(&mut object_333, var_332)?;
object_333.finish();
}
if let Some(var_334) = &input.sms_template {
#[allow(unused_mut)]
let mut object_335 = object.key("SMSTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_template(&mut object_335, var_334)?;
object_335.finish();
}
if let Some(var_336) = &input.voice_template {
#[allow(unused_mut)]
let mut object_337 = object.key("VoiceTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_template(&mut object_337, var_336)?;
object_337.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_in_app_message_content(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InAppMessageContent,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_338) = &input.background_color {
object.key("BackgroundColor").string(var_338.as_str());
}
if let Some(var_339) = &input.body_config {
#[allow(unused_mut)]
let mut object_340 = object.key("BodyConfig").start_object();
crate::json_ser::serialize_structure_crate_model_in_app_message_body_config(
&mut object_340,
var_339,
)?;
object_340.finish();
}
if let Some(var_341) = &input.header_config {
#[allow(unused_mut)]
let mut object_342 = object.key("HeaderConfig").start_object();
crate::json_ser::serialize_structure_crate_model_in_app_message_header_config(
&mut object_342,
var_341,
)?;
object_342.finish();
}
if let Some(var_343) = &input.image_url {
object.key("ImageUrl").string(var_343.as_str());
}
if let Some(var_344) = &input.primary_btn {
#[allow(unused_mut)]
let mut object_345 = object.key("PrimaryBtn").start_object();
crate::json_ser::serialize_structure_crate_model_in_app_message_button(
&mut object_345,
var_344,
)?;
object_345.finish();
}
if let Some(var_346) = &input.secondary_btn {
#[allow(unused_mut)]
let mut object_347 = object.key("SecondaryBtn").start_object();
crate::json_ser::serialize_structure_crate_model_in_app_message_button(
&mut object_347,
var_346,
)?;
object_347.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_activity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Activity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_348) = &input.custom {
#[allow(unused_mut)]
let mut object_349 = object.key("CUSTOM").start_object();
crate::json_ser::serialize_structure_crate_model_custom_message_activity(
&mut object_349,
var_348,
)?;
object_349.finish();
}
if let Some(var_350) = &input.conditional_split {
#[allow(unused_mut)]
let mut object_351 = object.key("ConditionalSplit").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_split_activity(
&mut object_351,
var_350,
)?;
object_351.finish();
}
if let Some(var_352) = &input.description {
object.key("Description").string(var_352.as_str());
}
if let Some(var_353) = &input.email {
#[allow(unused_mut)]
let mut object_354 = object.key("EMAIL").start_object();
crate::json_ser::serialize_structure_crate_model_email_message_activity(
&mut object_354,
var_353,
)?;
object_354.finish();
}
if let Some(var_355) = &input.holdout {
#[allow(unused_mut)]
let mut object_356 = object.key("Holdout").start_object();
crate::json_ser::serialize_structure_crate_model_holdout_activity(
&mut object_356,
var_355,
)?;
object_356.finish();
}
if let Some(var_357) = &input.multi_condition {
#[allow(unused_mut)]
let mut object_358 = object.key("MultiCondition").start_object();
crate::json_ser::serialize_structure_crate_model_multi_conditional_split_activity(
&mut object_358,
var_357,
)?;
object_358.finish();
}
if let Some(var_359) = &input.push {
#[allow(unused_mut)]
let mut object_360 = object.key("PUSH").start_object();
crate::json_ser::serialize_structure_crate_model_push_message_activity(
&mut object_360,
var_359,
)?;
object_360.finish();
}
if let Some(var_361) = &input.random_split {
#[allow(unused_mut)]
let mut object_362 = object.key("RandomSplit").start_object();
crate::json_ser::serialize_structure_crate_model_random_split_activity(
&mut object_362,
var_361,
)?;
object_362.finish();
}
if let Some(var_363) = &input.sms {
#[allow(unused_mut)]
let mut object_364 = object.key("SMS").start_object();
crate::json_ser::serialize_structure_crate_model_sms_message_activity(
&mut object_364,
var_363,
)?;
object_364.finish();
}
if let Some(var_365) = &input.wait {
#[allow(unused_mut)]
let mut object_366 = object.key("Wait").start_object();
crate::json_ser::serialize_structure_crate_model_wait_activity(&mut object_366, var_365)?;
object_366.finish();
}
if let Some(var_367) = &input.contact_center {
#[allow(unused_mut)]
let mut object_368 = object.key("ContactCenter").start_object();
crate::json_ser::serialize_structure_crate_model_contact_center_activity(
&mut object_368,
var_367,
)?;
object_368.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_journey_limits(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JourneyLimits,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.daily_cap != 0 {
object.key("DailyCap").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.daily_cap).into()),
);
}
if input.endpoint_reentry_cap != 0 {
object.key("EndpointReentryCap").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.endpoint_reentry_cap).into()),
);
}
if input.messages_per_second != 0 {
object.key("MessagesPerSecond").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.messages_per_second).into()),
);
}
if let Some(var_369) = &input.endpoint_reentry_interval {
object
.key("EndpointReentryInterval")
.string(var_369.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_quiet_time(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::QuietTime,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_370) = &input.end {
object.key("End").string(var_370.as_str());
}
if let Some(var_371) = &input.start {
object.key("Start").string(var_371.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_journey_schedule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JourneySchedule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_372) = &input.end_time {
object
.key("EndTime")
.date_time(var_372, aws_smithy_types::date_time::Format::DateTime)?;
}
if let Some(var_373) = &input.start_time {
object
.key("StartTime")
.date_time(var_373, aws_smithy_types::date_time::Format::DateTime)?;
}
if let Some(var_374) = &input.timezone {
object.key("Timezone").string(var_374.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_start_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StartCondition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_375) = &input.description {
object.key("Description").string(var_375.as_str());
}
if let Some(var_376) = &input.event_start_condition {
#[allow(unused_mut)]
let mut object_377 = object.key("EventStartCondition").start_object();
crate::json_ser::serialize_structure_crate_model_event_start_condition(
&mut object_377,
var_376,
)?;
object_377.finish();
}
if let Some(var_378) = &input.segment_start_condition {
#[allow(unused_mut)]
let mut object_379 = object.key("SegmentStartCondition").start_object();
crate::json_ser::serialize_structure_crate_model_segment_condition(
&mut object_379,
var_378,
)?;
object_379.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_journey_channel_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JourneyChannelSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_380) = &input.connect_campaign_arn {
object.key("ConnectCampaignArn").string(var_380.as_str());
}
if let Some(var_381) = &input.connect_campaign_execution_role_arn {
object
.key("ConnectCampaignExecutionRoleArn")
.string(var_381.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_open_hours(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OpenHours,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_382) = &input.email {
#[allow(unused_mut)]
let mut object_383 = object.key("EMAIL").start_object();
for (key_384, value_385) in var_382 {
{
let mut array_386 = object_383.key(key_384.as_str()).start_array();
for item_387 in value_385 {
{
#[allow(unused_mut)]
let mut object_388 = array_386.value().start_object();
crate::json_ser::serialize_structure_crate_model_open_hours_rule(
&mut object_388,
item_387,
)?;
object_388.finish();
}
}
array_386.finish();
}
}
object_383.finish();
}
if let Some(var_389) = &input.sms {
#[allow(unused_mut)]
let mut object_390 = object.key("SMS").start_object();
for (key_391, value_392) in var_389 {
{
let mut array_393 = object_390.key(key_391.as_str()).start_array();
for item_394 in value_392 {
{
#[allow(unused_mut)]
let mut object_395 = array_393.value().start_object();
crate::json_ser::serialize_structure_crate_model_open_hours_rule(
&mut object_395,
item_394,
)?;
object_395.finish();
}
}
array_393.finish();
}
}
object_390.finish();
}
if let Some(var_396) = &input.push {
#[allow(unused_mut)]
let mut object_397 = object.key("PUSH").start_object();
for (key_398, value_399) in var_396 {
{
let mut array_400 = object_397.key(key_398.as_str()).start_array();
for item_401 in value_399 {
{
#[allow(unused_mut)]
let mut object_402 = array_400.value().start_object();
crate::json_ser::serialize_structure_crate_model_open_hours_rule(
&mut object_402,
item_401,
)?;
object_402.finish();
}
}
array_400.finish();
}
}
object_397.finish();
}
if let Some(var_403) = &input.voice {
#[allow(unused_mut)]
let mut object_404 = object.key("VOICE").start_object();
for (key_405, value_406) in var_403 {
{
let mut array_407 = object_404.key(key_405.as_str()).start_array();
for item_408 in value_406 {
{
#[allow(unused_mut)]
let mut object_409 = array_407.value().start_object();
crate::json_ser::serialize_structure_crate_model_open_hours_rule(
&mut object_409,
item_408,
)?;
object_409.finish();
}
}
array_407.finish();
}
}
object_404.finish();
}
if let Some(var_410) = &input.custom {
#[allow(unused_mut)]
let mut object_411 = object.key("CUSTOM").start_object();
for (key_412, value_413) in var_410 {
{
let mut array_414 = object_411.key(key_412.as_str()).start_array();
for item_415 in value_413 {
{
#[allow(unused_mut)]
let mut object_416 = array_414.value().start_object();
crate::json_ser::serialize_structure_crate_model_open_hours_rule(
&mut object_416,
item_415,
)?;
object_416.finish();
}
}
array_414.finish();
}
}
object_411.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_closed_days(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ClosedDays,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_417) = &input.email {
let mut array_418 = object.key("EMAIL").start_array();
for item_419 in var_417 {
{
#[allow(unused_mut)]
let mut object_420 = array_418.value().start_object();
crate::json_ser::serialize_structure_crate_model_closed_days_rule(
&mut object_420,
item_419,
)?;
object_420.finish();
}
}
array_418.finish();
}
if let Some(var_421) = &input.sms {
let mut array_422 = object.key("SMS").start_array();
for item_423 in var_421 {
{
#[allow(unused_mut)]
let mut object_424 = array_422.value().start_object();
crate::json_ser::serialize_structure_crate_model_closed_days_rule(
&mut object_424,
item_423,
)?;
object_424.finish();
}
}
array_422.finish();
}
if let Some(var_425) = &input.push {
let mut array_426 = object.key("PUSH").start_array();
for item_427 in var_425 {
{
#[allow(unused_mut)]
let mut object_428 = array_426.value().start_object();
crate::json_ser::serialize_structure_crate_model_closed_days_rule(
&mut object_428,
item_427,
)?;
object_428.finish();
}
}
array_426.finish();
}
if let Some(var_429) = &input.voice {
let mut array_430 = object.key("VOICE").start_array();
for item_431 in var_429 {
{
#[allow(unused_mut)]
let mut object_432 = array_430.value().start_object();
crate::json_ser::serialize_structure_crate_model_closed_days_rule(
&mut object_432,
item_431,
)?;
object_432.finish();
}
}
array_430.finish();
}
if let Some(var_433) = &input.custom {
let mut array_434 = object.key("CUSTOM").start_array();
for item_435 in var_433 {
{
#[allow(unused_mut)]
let mut object_436 = array_434.value().start_object();
crate::json_ser::serialize_structure_crate_model_closed_days_rule(
&mut object_436,
item_435,
)?;
object_436.finish();
}
}
array_434.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_android_push_notification_template(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AndroidPushNotificationTemplate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_437) = &input.action {
object.key("Action").string(var_437.as_str());
}
if let Some(var_438) = &input.body {
object.key("Body").string(var_438.as_str());
}
if let Some(var_439) = &input.image_icon_url {
object.key("ImageIconUrl").string(var_439.as_str());
}
if let Some(var_440) = &input.image_url {
object.key("ImageUrl").string(var_440.as_str());
}
if let Some(var_441) = &input.raw_content {
object.key("RawContent").string(var_441.as_str());
}
if let Some(var_442) = &input.small_image_icon_url {
object.key("SmallImageIconUrl").string(var_442.as_str());
}
if let Some(var_443) = &input.sound {
object.key("Sound").string(var_443.as_str());
}
if let Some(var_444) = &input.title {
object.key("Title").string(var_444.as_str());
}
if let Some(var_445) = &input.url {
object.key("Url").string(var_445.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_apns_push_notification_template(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ApnsPushNotificationTemplate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_446) = &input.action {
object.key("Action").string(var_446.as_str());
}
if let Some(var_447) = &input.body {
object.key("Body").string(var_447.as_str());
}
if let Some(var_448) = &input.media_url {
object.key("MediaUrl").string(var_448.as_str());
}
if let Some(var_449) = &input.raw_content {
object.key("RawContent").string(var_449.as_str());
}
if let Some(var_450) = &input.sound {
object.key("Sound").string(var_450.as_str());
}
if let Some(var_451) = &input.title {
object.key("Title").string(var_451.as_str());
}
if let Some(var_452) = &input.url {
object.key("Url").string(var_452.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_default_push_notification_template(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DefaultPushNotificationTemplate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_453) = &input.action {
object.key("Action").string(var_453.as_str());
}
if let Some(var_454) = &input.body {
object.key("Body").string(var_454.as_str());
}
if let Some(var_455) = &input.sound {
object.key("Sound").string(var_455.as_str());
}
if let Some(var_456) = &input.title {
object.key("Title").string(var_456.as_str());
}
if let Some(var_457) = &input.url {
object.key("Url").string(var_457.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_segment_dimensions(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SegmentDimensions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_458) = &input.attributes {
#[allow(unused_mut)]
let mut object_459 = object.key("Attributes").start_object();
for (key_460, value_461) in var_458 {
{
#[allow(unused_mut)]
let mut object_462 = object_459.key(key_460.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_attribute_dimension(
&mut object_462,
value_461,
)?;
object_462.finish();
}
}
object_459.finish();
}
if let Some(var_463) = &input.behavior {
#[allow(unused_mut)]
let mut object_464 = object.key("Behavior").start_object();
crate::json_ser::serialize_structure_crate_model_segment_behaviors(
&mut object_464,
var_463,
)?;
object_464.finish();
}
if let Some(var_465) = &input.demographic {
#[allow(unused_mut)]
let mut object_466 = object.key("Demographic").start_object();
crate::json_ser::serialize_structure_crate_model_segment_demographics(
&mut object_466,
var_465,
)?;
object_466.finish();
}
if let Some(var_467) = &input.location {
#[allow(unused_mut)]
let mut object_468 = object.key("Location").start_object();
crate::json_ser::serialize_structure_crate_model_segment_location(
&mut object_468,
var_467,
)?;
object_468.finish();
}
if let Some(var_469) = &input.metrics {
#[allow(unused_mut)]
let mut object_470 = object.key("Metrics").start_object();
for (key_471, value_472) in var_469 {
{
#[allow(unused_mut)]
let mut object_473 = object_470.key(key_471.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_metric_dimension(
&mut object_473,
value_472,
)?;
object_473.finish();
}
}
object_470.finish();
}
if let Some(var_474) = &input.user_attributes {
#[allow(unused_mut)]
let mut object_475 = object.key("UserAttributes").start_object();
for (key_476, value_477) in var_474 {
{
#[allow(unused_mut)]
let mut object_478 = object_475.key(key_476.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_attribute_dimension(
&mut object_478,
value_477,
)?;
object_478.finish();
}
}
object_475.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_segment_group_list(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SegmentGroupList,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_479) = &input.groups {
let mut array_480 = object.key("Groups").start_array();
for item_481 in var_479 {
{
#[allow(unused_mut)]
let mut object_482 = array_480.value().start_object();
crate::json_ser::serialize_structure_crate_model_segment_group(
&mut object_482,
item_481,
)?;
object_482.finish();
}
}
array_480.finish();
}
if let Some(var_483) = &input.include {
object.key("Include").string(var_483.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_events_batch(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EventsBatch,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_484) = &input.endpoint {
#[allow(unused_mut)]
let mut object_485 = object.key("Endpoint").start_object();
crate::json_ser::serialize_structure_crate_model_public_endpoint(&mut object_485, var_484)?;
object_485.finish();
}
if let Some(var_486) = &input.events {
#[allow(unused_mut)]
let mut object_487 = object.key("Events").start_object();
for (key_488, value_489) in var_486 {
{
#[allow(unused_mut)]
let mut object_490 = object_487.key(key_488.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_event(&mut object_490, value_489)?;
object_490.finish();
}
}
object_487.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_address_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AddressConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_491) = &input.body_override {
object.key("BodyOverride").string(var_491.as_str());
}
if let Some(var_492) = &input.channel_type {
object.key("ChannelType").string(var_492.as_str());
}
if let Some(var_493) = &input.context {
#[allow(unused_mut)]
let mut object_494 = object.key("Context").start_object();
for (key_495, value_496) in var_493 {
{
object_494.key(key_495.as_str()).string(value_496.as_str());
}
}
object_494.finish();
}
if let Some(var_497) = &input.raw_content {
object.key("RawContent").string(var_497.as_str());
}
if let Some(var_498) = &input.substitutions {
#[allow(unused_mut)]
let mut object_499 = object.key("Substitutions").start_object();
for (key_500, value_501) in var_498 {
{
let mut array_502 = object_499.key(key_500.as_str()).start_array();
for item_503 in value_501 {
{
array_502.value().string(item_503.as_str());
}
}
array_502.finish();
}
}
object_499.finish();
}
if let Some(var_504) = &input.title_override {
object.key("TitleOverride").string(var_504.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_endpoint_send_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EndpointSendConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_505) = &input.body_override {
object.key("BodyOverride").string(var_505.as_str());
}
if let Some(var_506) = &input.context {
#[allow(unused_mut)]
let mut object_507 = object.key("Context").start_object();
for (key_508, value_509) in var_506 {
{
object_507.key(key_508.as_str()).string(value_509.as_str());
}
}
object_507.finish();
}
if let Some(var_510) = &input.raw_content {
object.key("RawContent").string(var_510.as_str());
}
if let Some(var_511) = &input.substitutions {
#[allow(unused_mut)]
let mut object_512 = object.key("Substitutions").start_object();
for (key_513, value_514) in var_511 {
{
let mut array_515 = object_512.key(key_513.as_str()).start_array();
for item_516 in value_514 {
{
array_515.value().string(item_516.as_str());
}
}
array_515.finish();
}
}
object_512.finish();
}
if let Some(var_517) = &input.title_override {
object.key("TitleOverride").string(var_517.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_direct_message_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DirectMessageConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_518) = &input.adm_message {
#[allow(unused_mut)]
let mut object_519 = object.key("ADMMessage").start_object();
crate::json_ser::serialize_structure_crate_model_adm_message(&mut object_519, var_518)?;
object_519.finish();
}
if let Some(var_520) = &input.apns_message {
#[allow(unused_mut)]
let mut object_521 = object.key("APNSMessage").start_object();
crate::json_ser::serialize_structure_crate_model_apns_message(&mut object_521, var_520)?;
object_521.finish();
}
if let Some(var_522) = &input.baidu_message {
#[allow(unused_mut)]
let mut object_523 = object.key("BaiduMessage").start_object();
crate::json_ser::serialize_structure_crate_model_baidu_message(&mut object_523, var_522)?;
object_523.finish();
}
if let Some(var_524) = &input.default_message {
#[allow(unused_mut)]
let mut object_525 = object.key("DefaultMessage").start_object();
crate::json_ser::serialize_structure_crate_model_default_message(&mut object_525, var_524)?;
object_525.finish();
}
if let Some(var_526) = &input.default_push_notification_message {
#[allow(unused_mut)]
let mut object_527 = object.key("DefaultPushNotificationMessage").start_object();
crate::json_ser::serialize_structure_crate_model_default_push_notification_message(
&mut object_527,
var_526,
)?;
object_527.finish();
}
if let Some(var_528) = &input.email_message {
#[allow(unused_mut)]
let mut object_529 = object.key("EmailMessage").start_object();
crate::json_ser::serialize_structure_crate_model_email_message(&mut object_529, var_528)?;
object_529.finish();
}
if let Some(var_530) = &input.gcm_message {
#[allow(unused_mut)]
let mut object_531 = object.key("GCMMessage").start_object();
crate::json_ser::serialize_structure_crate_model_gcm_message(&mut object_531, var_530)?;
object_531.finish();
}
if let Some(var_532) = &input.sms_message {
#[allow(unused_mut)]
let mut object_533 = object.key("SMSMessage").start_object();
crate::json_ser::serialize_structure_crate_model_sms_message(&mut object_533, var_532)?;
object_533.finish();
}
if let Some(var_534) = &input.voice_message {
#[allow(unused_mut)]
let mut object_535 = object.key("VoiceMessage").start_object();
crate::json_ser::serialize_structure_crate_model_voice_message(&mut object_535, var_534)?;
object_535.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_endpoint_demographic(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EndpointDemographic,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_536) = &input.app_version {
object.key("AppVersion").string(var_536.as_str());
}
if let Some(var_537) = &input.locale {
object.key("Locale").string(var_537.as_str());
}
if let Some(var_538) = &input.make {
object.key("Make").string(var_538.as_str());
}
if let Some(var_539) = &input.model {
object.key("Model").string(var_539.as_str());
}
if let Some(var_540) = &input.model_version {
object.key("ModelVersion").string(var_540.as_str());
}
if let Some(var_541) = &input.platform {
object.key("Platform").string(var_541.as_str());
}
if let Some(var_542) = &input.platform_version {
object.key("PlatformVersion").string(var_542.as_str());
}
if let Some(var_543) = &input.timezone {
object.key("Timezone").string(var_543.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_endpoint_location(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EndpointLocation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_544) = &input.city {
object.key("City").string(var_544.as_str());
}
if let Some(var_545) = &input.country {
object.key("Country").string(var_545.as_str());
}
if input.latitude != 0.0 {
object.key("Latitude").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.latitude).into()),
);
}
if input.longitude != 0.0 {
object.key("Longitude").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.longitude).into()),
);
}
if let Some(var_546) = &input.postal_code {
object.key("PostalCode").string(var_546.as_str());
}
if let Some(var_547) = &input.region {
object.key("Region").string(var_547.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_endpoint_user(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EndpointUser,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_548) = &input.user_attributes {
#[allow(unused_mut)]
let mut object_549 = object.key("UserAttributes").start_object();
for (key_550, value_551) in var_548 {
{
let mut array_552 = object_549.key(key_550.as_str()).start_array();
for item_553 in value_551 {
{
array_552.value().string(item_553.as_str());
}
}
array_552.finish();
}
}
object_549.finish();
}
if let Some(var_554) = &input.user_id {
object.key("UserId").string(var_554.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_endpoint_batch_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EndpointBatchItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_555) = &input.address {
object.key("Address").string(var_555.as_str());
}
if let Some(var_556) = &input.attributes {
#[allow(unused_mut)]
let mut object_557 = object.key("Attributes").start_object();
for (key_558, value_559) in var_556 {
{
let mut array_560 = object_557.key(key_558.as_str()).start_array();
for item_561 in value_559 {
{
array_560.value().string(item_561.as_str());
}
}
array_560.finish();
}
}
object_557.finish();
}
if let Some(var_562) = &input.channel_type {
object.key("ChannelType").string(var_562.as_str());
}
if let Some(var_563) = &input.demographic {
#[allow(unused_mut)]
let mut object_564 = object.key("Demographic").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_demographic(
&mut object_564,
var_563,
)?;
object_564.finish();
}
if let Some(var_565) = &input.effective_date {
object.key("EffectiveDate").string(var_565.as_str());
}
if let Some(var_566) = &input.endpoint_status {
object.key("EndpointStatus").string(var_566.as_str());
}
if let Some(var_567) = &input.id {
object.key("Id").string(var_567.as_str());
}
if let Some(var_568) = &input.location {
#[allow(unused_mut)]
let mut object_569 = object.key("Location").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_location(
&mut object_569,
var_568,
)?;
object_569.finish();
}
if let Some(var_570) = &input.metrics {
#[allow(unused_mut)]
let mut object_571 = object.key("Metrics").start_object();
for (key_572, value_573) in var_570 {
{
object_571.key(key_572.as_str()).number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*value_573).into()),
);
}
}
object_571.finish();
}
if let Some(var_574) = &input.opt_out {
object.key("OptOut").string(var_574.as_str());
}
if let Some(var_575) = &input.request_id {
object.key("RequestId").string(var_575.as_str());
}
if let Some(var_576) = &input.user {
#[allow(unused_mut)]
let mut object_577 = object.key("User").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_user(&mut object_577, var_576)?;
object_577.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Message,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_578) = &input.action {
object.key("Action").string(var_578.as_str());
}
if let Some(var_579) = &input.body {
object.key("Body").string(var_579.as_str());
}
if let Some(var_580) = &input.image_icon_url {
object.key("ImageIconUrl").string(var_580.as_str());
}
if let Some(var_581) = &input.image_small_icon_url {
object.key("ImageSmallIconUrl").string(var_581.as_str());
}
if let Some(var_582) = &input.image_url {
object.key("ImageUrl").string(var_582.as_str());
}
if let Some(var_583) = &input.json_body {
object.key("JsonBody").string(var_583.as_str());
}
if let Some(var_584) = &input.media_url {
object.key("MediaUrl").string(var_584.as_str());
}
if let Some(var_585) = &input.raw_content {
object.key("RawContent").string(var_585.as_str());
}
if input.silent_push {
object.key("SilentPush").boolean(input.silent_push);
}
if input.time_to_live != 0 {
object.key("TimeToLive").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.time_to_live).into()),
);
}
if let Some(var_586) = &input.title {
object.key("Title").string(var_586.as_str());
}
if let Some(var_587) = &input.url {
object.key("Url").string(var_587.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_campaign_custom_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CampaignCustomMessage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_588) = &input.data {
object.key("Data").string(var_588.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_campaign_email_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CampaignEmailMessage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_589) = &input.body {
object.key("Body").string(var_589.as_str());
}
if let Some(var_590) = &input.from_address {
object.key("FromAddress").string(var_590.as_str());
}
if let Some(var_591) = &input.html_body {
object.key("HtmlBody").string(var_591.as_str());
}
if let Some(var_592) = &input.title {
object.key("Title").string(var_592.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_campaign_sms_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CampaignSmsMessage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_593) = &input.body {
object.key("Body").string(var_593.as_str());
}
if let Some(var_594) = &input.message_type {
object.key("MessageType").string(var_594.as_str());
}
if let Some(var_595) = &input.origination_number {
object.key("OriginationNumber").string(var_595.as_str());
}
if let Some(var_596) = &input.sender_id {
object.key("SenderId").string(var_596.as_str());
}
if let Some(var_597) = &input.entity_id {
object.key("EntityId").string(var_597.as_str());
}
if let Some(var_598) = &input.template_id {
object.key("TemplateId").string(var_598.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_campaign_in_app_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CampaignInAppMessage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_599) = &input.body {
object.key("Body").string(var_599.as_str());
}
if let Some(var_600) = &input.content {
let mut array_601 = object.key("Content").start_array();
for item_602 in var_600 {
{
#[allow(unused_mut)]
let mut object_603 = array_601.value().start_object();
crate::json_ser::serialize_structure_crate_model_in_app_message_content(
&mut object_603,
item_602,
)?;
object_603.finish();
}
}
array_601.finish();
}
if let Some(var_604) = &input.custom_config {
#[allow(unused_mut)]
let mut object_605 = object.key("CustomConfig").start_object();
for (key_606, value_607) in var_604 {
{
object_605.key(key_606.as_str()).string(value_607.as_str());
}
}
object_605.finish();
}
if let Some(var_608) = &input.layout {
object.key("Layout").string(var_608.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_campaign_event_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CampaignEventFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_609) = &input.dimensions {
#[allow(unused_mut)]
let mut object_610 = object.key("Dimensions").start_object();
crate::json_ser::serialize_structure_crate_model_event_dimensions(
&mut object_610,
var_609,
)?;
object_610.finish();
}
if let Some(var_611) = &input.filter_type {
object.key("FilterType").string(var_611.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_template(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Template,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_612) = &input.name {
object.key("Name").string(var_612.as_str());
}
if let Some(var_613) = &input.version {
object.key("Version").string(var_613.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_in_app_message_body_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InAppMessageBodyConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_614) = &input.alignment {
object.key("Alignment").string(var_614.as_str());
}
if let Some(var_615) = &input.body {
object.key("Body").string(var_615.as_str());
}
if let Some(var_616) = &input.text_color {
object.key("TextColor").string(var_616.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_in_app_message_header_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InAppMessageHeaderConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_617) = &input.alignment {
object.key("Alignment").string(var_617.as_str());
}
if let Some(var_618) = &input.header {
object.key("Header").string(var_618.as_str());
}
if let Some(var_619) = &input.text_color {
object.key("TextColor").string(var_619.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_in_app_message_button(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InAppMessageButton,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_620) = &input.android {
#[allow(unused_mut)]
let mut object_621 = object.key("Android").start_object();
crate::json_ser::serialize_structure_crate_model_override_button_configuration(
&mut object_621,
var_620,
)?;
object_621.finish();
}
if let Some(var_622) = &input.default_config {
#[allow(unused_mut)]
let mut object_623 = object.key("DefaultConfig").start_object();
crate::json_ser::serialize_structure_crate_model_default_button_configuration(
&mut object_623,
var_622,
)?;
object_623.finish();
}
if let Some(var_624) = &input.ios {
#[allow(unused_mut)]
let mut object_625 = object.key("IOS").start_object();
crate::json_ser::serialize_structure_crate_model_override_button_configuration(
&mut object_625,
var_624,
)?;
object_625.finish();
}
if let Some(var_626) = &input.web {
#[allow(unused_mut)]
let mut object_627 = object.key("Web").start_object();
crate::json_ser::serialize_structure_crate_model_override_button_configuration(
&mut object_627,
var_626,
)?;
object_627.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_message_activity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomMessageActivity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_628) = &input.delivery_uri {
object.key("DeliveryUri").string(var_628.as_str());
}
if let Some(var_629) = &input.endpoint_types {
let mut array_630 = object.key("EndpointTypes").start_array();
for item_631 in var_629 {
{
array_630.value().string(item_631.as_str());
}
}
array_630.finish();
}
if let Some(var_632) = &input.message_config {
#[allow(unused_mut)]
let mut object_633 = object.key("MessageConfig").start_object();
crate::json_ser::serialize_structure_crate_model_journey_custom_message(
&mut object_633,
var_632,
)?;
object_633.finish();
}
if let Some(var_634) = &input.next_activity {
object.key("NextActivity").string(var_634.as_str());
}
if let Some(var_635) = &input.template_name {
object.key("TemplateName").string(var_635.as_str());
}
if let Some(var_636) = &input.template_version {
object.key("TemplateVersion").string(var_636.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_conditional_split_activity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConditionalSplitActivity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_637) = &input.condition {
#[allow(unused_mut)]
let mut object_638 = object.key("Condition").start_object();
crate::json_ser::serialize_structure_crate_model_condition(&mut object_638, var_637)?;
object_638.finish();
}
if let Some(var_639) = &input.evaluation_wait_time {
#[allow(unused_mut)]
let mut object_640 = object.key("EvaluationWaitTime").start_object();
crate::json_ser::serialize_structure_crate_model_wait_time(&mut object_640, var_639)?;
object_640.finish();
}
if let Some(var_641) = &input.false_activity {
object.key("FalseActivity").string(var_641.as_str());
}
if let Some(var_642) = &input.true_activity {
object.key("TrueActivity").string(var_642.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_email_message_activity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EmailMessageActivity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_643) = &input.message_config {
#[allow(unused_mut)]
let mut object_644 = object.key("MessageConfig").start_object();
crate::json_ser::serialize_structure_crate_model_journey_email_message(
&mut object_644,
var_643,
)?;
object_644.finish();
}
if let Some(var_645) = &input.next_activity {
object.key("NextActivity").string(var_645.as_str());
}
if let Some(var_646) = &input.template_name {
object.key("TemplateName").string(var_646.as_str());
}
if let Some(var_647) = &input.template_version {
object.key("TemplateVersion").string(var_647.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_holdout_activity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HoldoutActivity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_648) = &input.next_activity {
object.key("NextActivity").string(var_648.as_str());
}
{
object.key("Percentage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.percentage).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_multi_conditional_split_activity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MultiConditionalSplitActivity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_649) = &input.branches {
let mut array_650 = object.key("Branches").start_array();
for item_651 in var_649 {
{
#[allow(unused_mut)]
let mut object_652 = array_650.value().start_object();
crate::json_ser::serialize_structure_crate_model_multi_conditional_branch(
&mut object_652,
item_651,
)?;
object_652.finish();
}
}
array_650.finish();
}
if let Some(var_653) = &input.default_activity {
object.key("DefaultActivity").string(var_653.as_str());
}
if let Some(var_654) = &input.evaluation_wait_time {
#[allow(unused_mut)]
let mut object_655 = object.key("EvaluationWaitTime").start_object();
crate::json_ser::serialize_structure_crate_model_wait_time(&mut object_655, var_654)?;
object_655.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_push_message_activity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PushMessageActivity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_656) = &input.message_config {
#[allow(unused_mut)]
let mut object_657 = object.key("MessageConfig").start_object();
crate::json_ser::serialize_structure_crate_model_journey_push_message(
&mut object_657,
var_656,
)?;
object_657.finish();
}
if let Some(var_658) = &input.next_activity {
object.key("NextActivity").string(var_658.as_str());
}
if let Some(var_659) = &input.template_name {
object.key("TemplateName").string(var_659.as_str());
}
if let Some(var_660) = &input.template_version {
object.key("TemplateVersion").string(var_660.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_random_split_activity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RandomSplitActivity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_661) = &input.branches {
let mut array_662 = object.key("Branches").start_array();
for item_663 in var_661 {
{
#[allow(unused_mut)]
let mut object_664 = array_662.value().start_object();
crate::json_ser::serialize_structure_crate_model_random_split_entry(
&mut object_664,
item_663,
)?;
object_664.finish();
}
}
array_662.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sms_message_activity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SmsMessageActivity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_665) = &input.message_config {
#[allow(unused_mut)]
let mut object_666 = object.key("MessageConfig").start_object();
crate::json_ser::serialize_structure_crate_model_journey_sms_message(
&mut object_666,
var_665,
)?;
object_666.finish();
}
if let Some(var_667) = &input.next_activity {
object.key("NextActivity").string(var_667.as_str());
}
if let Some(var_668) = &input.template_name {
object.key("TemplateName").string(var_668.as_str());
}
if let Some(var_669) = &input.template_version {
object.key("TemplateVersion").string(var_669.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_wait_activity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WaitActivity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_670) = &input.next_activity {
object.key("NextActivity").string(var_670.as_str());
}
if let Some(var_671) = &input.wait_time {
#[allow(unused_mut)]
let mut object_672 = object.key("WaitTime").start_object();
crate::json_ser::serialize_structure_crate_model_wait_time(&mut object_672, var_671)?;
object_672.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_contact_center_activity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ContactCenterActivity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_673) = &input.next_activity {
object.key("NextActivity").string(var_673.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_event_start_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EventStartCondition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_674) = &input.event_filter {
#[allow(unused_mut)]
let mut object_675 = object.key("EventFilter").start_object();
crate::json_ser::serialize_structure_crate_model_event_filter(&mut object_675, var_674)?;
object_675.finish();
}
if let Some(var_676) = &input.segment_id {
object.key("SegmentId").string(var_676.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_segment_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SegmentCondition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_677) = &input.segment_id {
object.key("SegmentId").string(var_677.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_open_hours_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OpenHoursRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_678) = &input.start_time {
object.key("StartTime").string(var_678.as_str());
}
if let Some(var_679) = &input.end_time {
object.key("EndTime").string(var_679.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_closed_days_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ClosedDaysRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_680) = &input.name {
object.key("Name").string(var_680.as_str());
}
if let Some(var_681) = &input.start_date_time {
object.key("StartDateTime").string(var_681.as_str());
}
if let Some(var_682) = &input.end_date_time {
object.key("EndDateTime").string(var_682.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_attribute_dimension(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AttributeDimension,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_683) = &input.attribute_type {
object.key("AttributeType").string(var_683.as_str());
}
if let Some(var_684) = &input.values {
let mut array_685 = object.key("Values").start_array();
for item_686 in var_684 {
{
array_685.value().string(item_686.as_str());
}
}
array_685.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_segment_behaviors(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SegmentBehaviors,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_687) = &input.recency {
#[allow(unused_mut)]
let mut object_688 = object.key("Recency").start_object();
crate::json_ser::serialize_structure_crate_model_recency_dimension(
&mut object_688,
var_687,
)?;
object_688.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_segment_demographics(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SegmentDemographics,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_689) = &input.app_version {
#[allow(unused_mut)]
let mut object_690 = object.key("AppVersion").start_object();
crate::json_ser::serialize_structure_crate_model_set_dimension(&mut object_690, var_689)?;
object_690.finish();
}
if let Some(var_691) = &input.channel {
#[allow(unused_mut)]
let mut object_692 = object.key("Channel").start_object();
crate::json_ser::serialize_structure_crate_model_set_dimension(&mut object_692, var_691)?;
object_692.finish();
}
if let Some(var_693) = &input.device_type {
#[allow(unused_mut)]
let mut object_694 = object.key("DeviceType").start_object();
crate::json_ser::serialize_structure_crate_model_set_dimension(&mut object_694, var_693)?;
object_694.finish();
}
if let Some(var_695) = &input.make {
#[allow(unused_mut)]
let mut object_696 = object.key("Make").start_object();
crate::json_ser::serialize_structure_crate_model_set_dimension(&mut object_696, var_695)?;
object_696.finish();
}
if let Some(var_697) = &input.model {
#[allow(unused_mut)]
let mut object_698 = object.key("Model").start_object();
crate::json_ser::serialize_structure_crate_model_set_dimension(&mut object_698, var_697)?;
object_698.finish();
}
if let Some(var_699) = &input.platform {
#[allow(unused_mut)]
let mut object_700 = object.key("Platform").start_object();
crate::json_ser::serialize_structure_crate_model_set_dimension(&mut object_700, var_699)?;
object_700.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_segment_location(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SegmentLocation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_701) = &input.country {
#[allow(unused_mut)]
let mut object_702 = object.key("Country").start_object();
crate::json_ser::serialize_structure_crate_model_set_dimension(&mut object_702, var_701)?;
object_702.finish();
}
if let Some(var_703) = &input.gps_point {
#[allow(unused_mut)]
let mut object_704 = object.key("GPSPoint").start_object();
crate::json_ser::serialize_structure_crate_model_gps_point_dimension(
&mut object_704,
var_703,
)?;
object_704.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_metric_dimension(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MetricDimension,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_705) = &input.comparison_operator {
object.key("ComparisonOperator").string(var_705.as_str());
}
{
object.key("Value").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.value).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_segment_group(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SegmentGroup,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_706) = &input.dimensions {
let mut array_707 = object.key("Dimensions").start_array();
for item_708 in var_706 {
{
#[allow(unused_mut)]
let mut object_709 = array_707.value().start_object();
crate::json_ser::serialize_structure_crate_model_segment_dimensions(
&mut object_709,
item_708,
)?;
object_709.finish();
}
}
array_707.finish();
}
if let Some(var_710) = &input.source_segments {
let mut array_711 = object.key("SourceSegments").start_array();
for item_712 in var_710 {
{
#[allow(unused_mut)]
let mut object_713 = array_711.value().start_object();
crate::json_ser::serialize_structure_crate_model_segment_reference(
&mut object_713,
item_712,
)?;
object_713.finish();
}
}
array_711.finish();
}
if let Some(var_714) = &input.source_type {
object.key("SourceType").string(var_714.as_str());
}
if let Some(var_715) = &input.r#type {
object.key("Type").string(var_715.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_public_endpoint(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PublicEndpoint,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_716) = &input.address {
object.key("Address").string(var_716.as_str());
}
if let Some(var_717) = &input.attributes {
#[allow(unused_mut)]
let mut object_718 = object.key("Attributes").start_object();
for (key_719, value_720) in var_717 {
{
let mut array_721 = object_718.key(key_719.as_str()).start_array();
for item_722 in value_720 {
{
array_721.value().string(item_722.as_str());
}
}
array_721.finish();
}
}
object_718.finish();
}
if let Some(var_723) = &input.channel_type {
object.key("ChannelType").string(var_723.as_str());
}
if let Some(var_724) = &input.demographic {
#[allow(unused_mut)]
let mut object_725 = object.key("Demographic").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_demographic(
&mut object_725,
var_724,
)?;
object_725.finish();
}
if let Some(var_726) = &input.effective_date {
object.key("EffectiveDate").string(var_726.as_str());
}
if let Some(var_727) = &input.endpoint_status {
object.key("EndpointStatus").string(var_727.as_str());
}
if let Some(var_728) = &input.location {
#[allow(unused_mut)]
let mut object_729 = object.key("Location").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_location(
&mut object_729,
var_728,
)?;
object_729.finish();
}
if let Some(var_730) = &input.metrics {
#[allow(unused_mut)]
let mut object_731 = object.key("Metrics").start_object();
for (key_732, value_733) in var_730 {
{
object_731.key(key_732.as_str()).number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*value_733).into()),
);
}
}
object_731.finish();
}
if let Some(var_734) = &input.opt_out {
object.key("OptOut").string(var_734.as_str());
}
if let Some(var_735) = &input.request_id {
object.key("RequestId").string(var_735.as_str());
}
if let Some(var_736) = &input.user {
#[allow(unused_mut)]
let mut object_737 = object.key("User").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_user(&mut object_737, var_736)?;
object_737.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_738) = &input.app_package_name {
object.key("AppPackageName").string(var_738.as_str());
}
if let Some(var_739) = &input.app_title {
object.key("AppTitle").string(var_739.as_str());
}
if let Some(var_740) = &input.app_version_code {
object.key("AppVersionCode").string(var_740.as_str());
}
if let Some(var_741) = &input.attributes {
#[allow(unused_mut)]
let mut object_742 = object.key("Attributes").start_object();
for (key_743, value_744) in var_741 {
{
object_742.key(key_743.as_str()).string(value_744.as_str());
}
}
object_742.finish();
}
if let Some(var_745) = &input.client_sdk_version {
object.key("ClientSdkVersion").string(var_745.as_str());
}
if let Some(var_746) = &input.event_type {
object.key("EventType").string(var_746.as_str());
}
if let Some(var_747) = &input.metrics {
#[allow(unused_mut)]
let mut object_748 = object.key("Metrics").start_object();
for (key_749, value_750) in var_747 {
{
object_748.key(key_749.as_str()).number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*value_750).into()),
);
}
}
object_748.finish();
}
if let Some(var_751) = &input.sdk_name {
object.key("SdkName").string(var_751.as_str());
}
if let Some(var_752) = &input.session {
#[allow(unused_mut)]
let mut object_753 = object.key("Session").start_object();
crate::json_ser::serialize_structure_crate_model_session(&mut object_753, var_752)?;
object_753.finish();
}
if let Some(var_754) = &input.timestamp {
object.key("Timestamp").string(var_754.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_adm_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AdmMessage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_755) = &input.action {
object.key("Action").string(var_755.as_str());
}
if let Some(var_756) = &input.body {
object.key("Body").string(var_756.as_str());
}
if let Some(var_757) = &input.consolidation_key {
object.key("ConsolidationKey").string(var_757.as_str());
}
if let Some(var_758) = &input.data {
#[allow(unused_mut)]
let mut object_759 = object.key("Data").start_object();
for (key_760, value_761) in var_758 {
{
object_759.key(key_760.as_str()).string(value_761.as_str());
}
}
object_759.finish();
}
if let Some(var_762) = &input.expires_after {
object.key("ExpiresAfter").string(var_762.as_str());
}
if let Some(var_763) = &input.icon_reference {
object.key("IconReference").string(var_763.as_str());
}
if let Some(var_764) = &input.image_icon_url {
object.key("ImageIconUrl").string(var_764.as_str());
}
if let Some(var_765) = &input.image_url {
object.key("ImageUrl").string(var_765.as_str());
}
if let Some(var_766) = &input.md5 {
object.key("MD5").string(var_766.as_str());
}
if let Some(var_767) = &input.raw_content {
object.key("RawContent").string(var_767.as_str());
}
if input.silent_push {
object.key("SilentPush").boolean(input.silent_push);
}
if let Some(var_768) = &input.small_image_icon_url {
object.key("SmallImageIconUrl").string(var_768.as_str());
}
if let Some(var_769) = &input.sound {
object.key("Sound").string(var_769.as_str());
}
if let Some(var_770) = &input.substitutions {
#[allow(unused_mut)]
let mut object_771 = object.key("Substitutions").start_object();
for (key_772, value_773) in var_770 {
{
let mut array_774 = object_771.key(key_772.as_str()).start_array();
for item_775 in value_773 {
{
array_774.value().string(item_775.as_str());
}
}
array_774.finish();
}
}
object_771.finish();
}
if let Some(var_776) = &input.title {
object.key("Title").string(var_776.as_str());
}
if let Some(var_777) = &input.url {
object.key("Url").string(var_777.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_apns_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ApnsMessage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_778) = &input.apns_push_type {
object.key("APNSPushType").string(var_778.as_str());
}
if let Some(var_779) = &input.action {
object.key("Action").string(var_779.as_str());
}
if input.badge != 0 {
object.key("Badge").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.badge).into()),
);
}
if let Some(var_780) = &input.body {
object.key("Body").string(var_780.as_str());
}
if let Some(var_781) = &input.category {
object.key("Category").string(var_781.as_str());
}
if let Some(var_782) = &input.collapse_id {
object.key("CollapseId").string(var_782.as_str());
}
if let Some(var_783) = &input.data {
#[allow(unused_mut)]
let mut object_784 = object.key("Data").start_object();
for (key_785, value_786) in var_783 {
{
object_784.key(key_785.as_str()).string(value_786.as_str());
}
}
object_784.finish();
}
if let Some(var_787) = &input.media_url {
object.key("MediaUrl").string(var_787.as_str());
}
if let Some(var_788) = &input.preferred_authentication_method {
object
.key("PreferredAuthenticationMethod")
.string(var_788.as_str());
}
if let Some(var_789) = &input.priority {
object.key("Priority").string(var_789.as_str());
}
if let Some(var_790) = &input.raw_content {
object.key("RawContent").string(var_790.as_str());
}
if input.silent_push {
object.key("SilentPush").boolean(input.silent_push);
}
if let Some(var_791) = &input.sound {
object.key("Sound").string(var_791.as_str());
}
if let Some(var_792) = &input.substitutions {
#[allow(unused_mut)]
let mut object_793 = object.key("Substitutions").start_object();
for (key_794, value_795) in var_792 {
{
let mut array_796 = object_793.key(key_794.as_str()).start_array();
for item_797 in value_795 {
{
array_796.value().string(item_797.as_str());
}
}
array_796.finish();
}
}
object_793.finish();
}
if let Some(var_798) = &input.thread_id {
object.key("ThreadId").string(var_798.as_str());
}
if input.time_to_live != 0 {
object.key("TimeToLive").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.time_to_live).into()),
);
}
if let Some(var_799) = &input.title {
object.key("Title").string(var_799.as_str());
}
if let Some(var_800) = &input.url {
object.key("Url").string(var_800.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_baidu_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BaiduMessage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_801) = &input.action {
object.key("Action").string(var_801.as_str());
}
if let Some(var_802) = &input.body {
object.key("Body").string(var_802.as_str());
}
if let Some(var_803) = &input.data {
#[allow(unused_mut)]
let mut object_804 = object.key("Data").start_object();
for (key_805, value_806) in var_803 {
{
object_804.key(key_805.as_str()).string(value_806.as_str());
}
}
object_804.finish();
}
if let Some(var_807) = &input.icon_reference {
object.key("IconReference").string(var_807.as_str());
}
if let Some(var_808) = &input.image_icon_url {
object.key("ImageIconUrl").string(var_808.as_str());
}
if let Some(var_809) = &input.image_url {
object.key("ImageUrl").string(var_809.as_str());
}
if let Some(var_810) = &input.raw_content {
object.key("RawContent").string(var_810.as_str());
}
if input.silent_push {
object.key("SilentPush").boolean(input.silent_push);
}
if let Some(var_811) = &input.small_image_icon_url {
object.key("SmallImageIconUrl").string(var_811.as_str());
}
if let Some(var_812) = &input.sound {
object.key("Sound").string(var_812.as_str());
}
if let Some(var_813) = &input.substitutions {
#[allow(unused_mut)]
let mut object_814 = object.key("Substitutions").start_object();
for (key_815, value_816) in var_813 {
{
let mut array_817 = object_814.key(key_815.as_str()).start_array();
for item_818 in value_816 {
{
array_817.value().string(item_818.as_str());
}
}
array_817.finish();
}
}
object_814.finish();
}
if input.time_to_live != 0 {
object.key("TimeToLive").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.time_to_live).into()),
);
}
if let Some(var_819) = &input.title {
object.key("Title").string(var_819.as_str());
}
if let Some(var_820) = &input.url {
object.key("Url").string(var_820.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_default_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DefaultMessage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_821) = &input.body {
object.key("Body").string(var_821.as_str());
}
if let Some(var_822) = &input.substitutions {
#[allow(unused_mut)]
let mut object_823 = object.key("Substitutions").start_object();
for (key_824, value_825) in var_822 {
{
let mut array_826 = object_823.key(key_824.as_str()).start_array();
for item_827 in value_825 {
{
array_826.value().string(item_827.as_str());
}
}
array_826.finish();
}
}
object_823.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_default_push_notification_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DefaultPushNotificationMessage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_828) = &input.action {
object.key("Action").string(var_828.as_str());
}
if let Some(var_829) = &input.body {
object.key("Body").string(var_829.as_str());
}
if let Some(var_830) = &input.data {
#[allow(unused_mut)]
let mut object_831 = object.key("Data").start_object();
for (key_832, value_833) in var_830 {
{
object_831.key(key_832.as_str()).string(value_833.as_str());
}
}
object_831.finish();
}
if input.silent_push {
object.key("SilentPush").boolean(input.silent_push);
}
if let Some(var_834) = &input.substitutions {
#[allow(unused_mut)]
let mut object_835 = object.key("Substitutions").start_object();
for (key_836, value_837) in var_834 {
{
let mut array_838 = object_835.key(key_836.as_str()).start_array();
for item_839 in value_837 {
{
array_838.value().string(item_839.as_str());
}
}
array_838.finish();
}
}
object_835.finish();
}
if let Some(var_840) = &input.title {
object.key("Title").string(var_840.as_str());
}
if let Some(var_841) = &input.url {
object.key("Url").string(var_841.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_email_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EmailMessage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_842) = &input.body {
object.key("Body").string(var_842.as_str());
}
if let Some(var_843) = &input.feedback_forwarding_address {
object
.key("FeedbackForwardingAddress")
.string(var_843.as_str());
}
if let Some(var_844) = &input.from_address {
object.key("FromAddress").string(var_844.as_str());
}
if let Some(var_845) = &input.raw_email {
#[allow(unused_mut)]
let mut object_846 = object.key("RawEmail").start_object();
crate::json_ser::serialize_structure_crate_model_raw_email(&mut object_846, var_845)?;
object_846.finish();
}
if let Some(var_847) = &input.reply_to_addresses {
let mut array_848 = object.key("ReplyToAddresses").start_array();
for item_849 in var_847 {
{
array_848.value().string(item_849.as_str());
}
}
array_848.finish();
}
if let Some(var_850) = &input.simple_email {
#[allow(unused_mut)]
let mut object_851 = object.key("SimpleEmail").start_object();
crate::json_ser::serialize_structure_crate_model_simple_email(&mut object_851, var_850)?;
object_851.finish();
}
if let Some(var_852) = &input.substitutions {
#[allow(unused_mut)]
let mut object_853 = object.key("Substitutions").start_object();
for (key_854, value_855) in var_852 {
{
let mut array_856 = object_853.key(key_854.as_str()).start_array();
for item_857 in value_855 {
{
array_856.value().string(item_857.as_str());
}
}
array_856.finish();
}
}
object_853.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_gcm_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GcmMessage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_858) = &input.action {
object.key("Action").string(var_858.as_str());
}
if let Some(var_859) = &input.body {
object.key("Body").string(var_859.as_str());
}
if let Some(var_860) = &input.collapse_key {
object.key("CollapseKey").string(var_860.as_str());
}
if let Some(var_861) = &input.data {
#[allow(unused_mut)]
let mut object_862 = object.key("Data").start_object();
for (key_863, value_864) in var_861 {
{
object_862.key(key_863.as_str()).string(value_864.as_str());
}
}
object_862.finish();
}
if let Some(var_865) = &input.icon_reference {
object.key("IconReference").string(var_865.as_str());
}
if let Some(var_866) = &input.image_icon_url {
object.key("ImageIconUrl").string(var_866.as_str());
}
if let Some(var_867) = &input.image_url {
object.key("ImageUrl").string(var_867.as_str());
}
if let Some(var_868) = &input.priority {
object.key("Priority").string(var_868.as_str());
}
if let Some(var_869) = &input.raw_content {
object.key("RawContent").string(var_869.as_str());
}
if let Some(var_870) = &input.restricted_package_name {
object.key("RestrictedPackageName").string(var_870.as_str());
}
if input.silent_push {
object.key("SilentPush").boolean(input.silent_push);
}
if let Some(var_871) = &input.small_image_icon_url {
object.key("SmallImageIconUrl").string(var_871.as_str());
}
if let Some(var_872) = &input.sound {
object.key("Sound").string(var_872.as_str());
}
if let Some(var_873) = &input.substitutions {
#[allow(unused_mut)]
let mut object_874 = object.key("Substitutions").start_object();
for (key_875, value_876) in var_873 {
{
let mut array_877 = object_874.key(key_875.as_str()).start_array();
for item_878 in value_876 {
{
array_877.value().string(item_878.as_str());
}
}
array_877.finish();
}
}
object_874.finish();
}
if input.time_to_live != 0 {
object.key("TimeToLive").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.time_to_live).into()),
);
}
if let Some(var_879) = &input.title {
object.key("Title").string(var_879.as_str());
}
if let Some(var_880) = &input.url {
object.key("Url").string(var_880.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sms_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SmsMessage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_881) = &input.body {
object.key("Body").string(var_881.as_str());
}
if let Some(var_882) = &input.keyword {
object.key("Keyword").string(var_882.as_str());
}
if let Some(var_883) = &input.media_url {
object.key("MediaUrl").string(var_883.as_str());
}
if let Some(var_884) = &input.message_type {
object.key("MessageType").string(var_884.as_str());
}
if let Some(var_885) = &input.origination_number {
object.key("OriginationNumber").string(var_885.as_str());
}
if let Some(var_886) = &input.sender_id {
object.key("SenderId").string(var_886.as_str());
}
if let Some(var_887) = &input.substitutions {
#[allow(unused_mut)]
let mut object_888 = object.key("Substitutions").start_object();
for (key_889, value_890) in var_887 {
{
let mut array_891 = object_888.key(key_889.as_str()).start_array();
for item_892 in value_890 {
{
array_891.value().string(item_892.as_str());
}
}
array_891.finish();
}
}
object_888.finish();
}
if let Some(var_893) = &input.entity_id {
object.key("EntityId").string(var_893.as_str());
}
if let Some(var_894) = &input.template_id {
object.key("TemplateId").string(var_894.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_voice_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VoiceMessage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_895) = &input.body {
object.key("Body").string(var_895.as_str());
}
if let Some(var_896) = &input.language_code {
object.key("LanguageCode").string(var_896.as_str());
}
if let Some(var_897) = &input.origination_number {
object.key("OriginationNumber").string(var_897.as_str());
}
if let Some(var_898) = &input.substitutions {
#[allow(unused_mut)]
let mut object_899 = object.key("Substitutions").start_object();
for (key_900, value_901) in var_898 {
{
let mut array_902 = object_899.key(key_900.as_str()).start_array();
for item_903 in value_901 {
{
array_902.value().string(item_903.as_str());
}
}
array_902.finish();
}
}
object_899.finish();
}
if let Some(var_904) = &input.voice_id {
object.key("VoiceId").string(var_904.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_event_dimensions(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EventDimensions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_905) = &input.attributes {
#[allow(unused_mut)]
let mut object_906 = object.key("Attributes").start_object();
for (key_907, value_908) in var_905 {
{
#[allow(unused_mut)]
let mut object_909 = object_906.key(key_907.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_attribute_dimension(
&mut object_909,
value_908,
)?;
object_909.finish();
}
}
object_906.finish();
}
if let Some(var_910) = &input.event_type {
#[allow(unused_mut)]
let mut object_911 = object.key("EventType").start_object();
crate::json_ser::serialize_structure_crate_model_set_dimension(&mut object_911, var_910)?;
object_911.finish();
}
if let Some(var_912) = &input.metrics {
#[allow(unused_mut)]
let mut object_913 = object.key("Metrics").start_object();
for (key_914, value_915) in var_912 {
{
#[allow(unused_mut)]
let mut object_916 = object_913.key(key_914.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_metric_dimension(
&mut object_916,
value_915,
)?;
object_916.finish();
}
}
object_913.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_override_button_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OverrideButtonConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_917) = &input.button_action {
object.key("ButtonAction").string(var_917.as_str());
}
if let Some(var_918) = &input.link {
object.key("Link").string(var_918.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_default_button_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DefaultButtonConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_919) = &input.background_color {
object.key("BackgroundColor").string(var_919.as_str());
}
if input.border_radius != 0 {
object.key("BorderRadius").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.border_radius).into()),
);
}
if let Some(var_920) = &input.button_action {
object.key("ButtonAction").string(var_920.as_str());
}
if let Some(var_921) = &input.link {
object.key("Link").string(var_921.as_str());
}
if let Some(var_922) = &input.text {
object.key("Text").string(var_922.as_str());
}
if let Some(var_923) = &input.text_color {
object.key("TextColor").string(var_923.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_journey_custom_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JourneyCustomMessage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_924) = &input.data {
object.key("Data").string(var_924.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Condition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_925) = &input.conditions {
let mut array_926 = object.key("Conditions").start_array();
for item_927 in var_925 {
{
#[allow(unused_mut)]
let mut object_928 = array_926.value().start_object();
crate::json_ser::serialize_structure_crate_model_simple_condition(
&mut object_928,
item_927,
)?;
object_928.finish();
}
}
array_926.finish();
}
if let Some(var_929) = &input.operator {
object.key("Operator").string(var_929.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_wait_time(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WaitTime,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_930) = &input.wait_for {
object.key("WaitFor").string(var_930.as_str());
}
if let Some(var_931) = &input.wait_until {
object.key("WaitUntil").string(var_931.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_journey_email_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JourneyEmailMessage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_932) = &input.from_address {
object.key("FromAddress").string(var_932.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_multi_conditional_branch(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MultiConditionalBranch,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_933) = &input.condition {
#[allow(unused_mut)]
let mut object_934 = object.key("Condition").start_object();
crate::json_ser::serialize_structure_crate_model_simple_condition(
&mut object_934,
var_933,
)?;
object_934.finish();
}
if let Some(var_935) = &input.next_activity {
object.key("NextActivity").string(var_935.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_journey_push_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JourneyPushMessage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_936) = &input.time_to_live {
object.key("TimeToLive").string(var_936.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_random_split_entry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RandomSplitEntry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_937) = &input.next_activity {
object.key("NextActivity").string(var_937.as_str());
}
if input.percentage != 0 {
object.key("Percentage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.percentage).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_journey_sms_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JourneySmsMessage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_938) = &input.message_type {
object.key("MessageType").string(var_938.as_str());
}
if let Some(var_939) = &input.origination_number {
object.key("OriginationNumber").string(var_939.as_str());
}
if let Some(var_940) = &input.sender_id {
object.key("SenderId").string(var_940.as_str());
}
if let Some(var_941) = &input.entity_id {
object.key("EntityId").string(var_941.as_str());
}
if let Some(var_942) = &input.template_id {
object.key("TemplateId").string(var_942.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_event_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EventFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_943) = &input.dimensions {
#[allow(unused_mut)]
let mut object_944 = object.key("Dimensions").start_object();
crate::json_ser::serialize_structure_crate_model_event_dimensions(
&mut object_944,
var_943,
)?;
object_944.finish();
}
if let Some(var_945) = &input.filter_type {
object.key("FilterType").string(var_945.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_recency_dimension(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RecencyDimension,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_946) = &input.duration {
object.key("Duration").string(var_946.as_str());
}
if let Some(var_947) = &input.recency_type {
object.key("RecencyType").string(var_947.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_set_dimension(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SetDimension,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_948) = &input.dimension_type {
object.key("DimensionType").string(var_948.as_str());
}
if let Some(var_949) = &input.values {
let mut array_950 = object.key("Values").start_array();
for item_951 in var_949 {
{
array_950.value().string(item_951.as_str());
}
}
array_950.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_gps_point_dimension(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GpsPointDimension,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_952) = &input.coordinates {
#[allow(unused_mut)]
let mut object_953 = object.key("Coordinates").start_object();
crate::json_ser::serialize_structure_crate_model_gps_coordinates(&mut object_953, var_952)?;
object_953.finish();
}
if input.range_in_kilometers != 0.0 {
object.key("RangeInKilometers").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.range_in_kilometers).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_segment_reference(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SegmentReference,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_954) = &input.id {
object.key("Id").string(var_954.as_str());
}
if input.version != 0 {
object.key("Version").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.version).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_session(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Session,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.duration != 0 {
object.key("Duration").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.duration).into()),
);
}
if let Some(var_955) = &input.id {
object.key("Id").string(var_955.as_str());
}
if let Some(var_956) = &input.start_timestamp {
object.key("StartTimestamp").string(var_956.as_str());
}
if let Some(var_957) = &input.stop_timestamp {
object.key("StopTimestamp").string(var_957.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_raw_email(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RawEmail,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_958) = &input.data {
object
.key("Data")
.string_unchecked(&aws_smithy_types::base64::encode(var_958));
}
Ok(())
}
pub fn serialize_structure_crate_model_simple_email(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SimpleEmail,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_959) = &input.html_part {
#[allow(unused_mut)]
let mut object_960 = object.key("HtmlPart").start_object();
crate::json_ser::serialize_structure_crate_model_simple_email_part(
&mut object_960,
var_959,
)?;
object_960.finish();
}
if let Some(var_961) = &input.subject {
#[allow(unused_mut)]
let mut object_962 = object.key("Subject").start_object();
crate::json_ser::serialize_structure_crate_model_simple_email_part(
&mut object_962,
var_961,
)?;
object_962.finish();
}
if let Some(var_963) = &input.text_part {
#[allow(unused_mut)]
let mut object_964 = object.key("TextPart").start_object();
crate::json_ser::serialize_structure_crate_model_simple_email_part(
&mut object_964,
var_963,
)?;
object_964.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_simple_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SimpleCondition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_965) = &input.event_condition {
#[allow(unused_mut)]
let mut object_966 = object.key("EventCondition").start_object();
crate::json_ser::serialize_structure_crate_model_event_condition(&mut object_966, var_965)?;
object_966.finish();
}
if let Some(var_967) = &input.segment_condition {
#[allow(unused_mut)]
let mut object_968 = object.key("SegmentCondition").start_object();
crate::json_ser::serialize_structure_crate_model_segment_condition(
&mut object_968,
var_967,
)?;
object_968.finish();
}
if let Some(var_969) = &input.segment_dimensions {
#[allow(unused_mut)]
let mut object_970 = object.key("segmentDimensions").start_object();
crate::json_ser::serialize_structure_crate_model_segment_dimensions(
&mut object_970,
var_969,
)?;
object_970.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_gps_coordinates(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GpsCoordinates,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("Latitude").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.latitude).into()),
);
}
{
object.key("Longitude").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.longitude).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_simple_email_part(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SimpleEmailPart,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_971) = &input.charset {
object.key("Charset").string(var_971.as_str());
}
if let Some(var_972) = &input.data {
object.key("Data").string(var_972.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_event_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EventCondition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_973) = &input.dimensions {
#[allow(unused_mut)]
let mut object_974 = object.key("Dimensions").start_object();
crate::json_ser::serialize_structure_crate_model_event_dimensions(
&mut object_974,
var_973,
)?;
object_974.finish();
}
if let Some(var_975) = &input.message_activity {
object.key("MessageActivity").string(var_975.as_str());
}
Ok(())
}