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::SerializationError> {
if let Some(var_1) = &input.name {
object.key("Name").string(var_1.as_str());
}
if let Some(var_2) = &input.tags {
let mut object_3 = object.key("tags").start_object();
for (key_4, value_5) in var_2 {
{
object_3.key(key_4).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::SerializationError> {
if let Some(var_6) = &input.additional_treatments {
let mut array_7 = object.key("AdditionalTreatments").start_array();
for item_8 in var_6 {
{
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 {
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 {
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 {
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 {
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 {
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 {
let mut object_24 = object.key("tags").start_object();
for (key_25, value_26) in var_23 {
{
object_24.key(key_25).string(value_26.as_str());
}
}
object_24.finish();
}
if let Some(var_27) = &input.template_configuration {
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::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 {
let mut object_36 = object.key("tags").start_object();
for (key_37, value_38) in var_35 {
{
object_36.key(key_37).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::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::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::SerializationError> {
if let Some(var_50) = &input.content {
let mut array_51 = object.key("Content").start_array();
for item_52 in var_50 {
{
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 {
let mut object_55 = object.key("CustomConfig").start_object();
for (key_56, value_57) in var_54 {
{
object_55.key(key_56).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 {
let mut object_60 = object.key("tags").start_object();
for (key_61, value_62) in var_59 {
{
object_60.key(key_61).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::SerializationError> {
if let Some(var_64) = &input.activities {
let mut object_65 = object.key("Activities").start_object();
for (key_66, value_67) in var_64 {
{
let mut object_68 = object_65.key(key_66).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 {
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 {
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 {
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 {
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 {
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();
}
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::SerializationError> {
if let Some(var_85) = &input.adm {
let mut object_86 = object.key("ADM").start_object();
crate::json_ser::serialize_structure_crate_model_android_push_notification_template(
&mut object_86,
var_85,
)?;
object_86.finish();
}
if let Some(var_87) = &input.apns {
let mut object_88 = object.key("APNS").start_object();
crate::json_ser::serialize_structure_crate_model_apns_push_notification_template(
&mut object_88,
var_87,
)?;
object_88.finish();
}
if let Some(var_89) = &input.baidu {
let mut object_90 = object.key("Baidu").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.default_value {
let mut object_92 = object.key("Default").start_object();
crate::json_ser::serialize_structure_crate_model_default_push_notification_template(
&mut object_92,
var_91,
)?;
object_92.finish();
}
if let Some(var_93) = &input.default_substitutions {
object.key("DefaultSubstitutions").string(var_93.as_str());
}
if let Some(var_94) = &input.gcm {
let mut object_95 = object.key("GCM").start_object();
crate::json_ser::serialize_structure_crate_model_android_push_notification_template(
&mut object_95,
var_94,
)?;
object_95.finish();
}
if let Some(var_96) = &input.recommender_id {
object.key("RecommenderId").string(var_96.as_str());
}
if let Some(var_97) = &input.tags {
let mut object_98 = object.key("tags").start_object();
for (key_99, value_100) in var_97 {
{
object_98.key(key_99).string(value_100.as_str());
}
}
object_98.finish();
}
if let Some(var_101) = &input.template_description {
object.key("TemplateDescription").string(var_101.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::SerializationError> {
if let Some(var_102) = &input.attributes {
let mut object_103 = object.key("Attributes").start_object();
for (key_104, value_105) in var_102 {
{
object_103.key(key_104).string(value_105.as_str());
}
}
object_103.finish();
}
if let Some(var_106) = &input.description {
object.key("Description").string(var_106.as_str());
}
if let Some(var_107) = &input.name {
object.key("Name").string(var_107.as_str());
}
if let Some(var_108) = &input.recommendation_provider_id_type {
object
.key("RecommendationProviderIdType")
.string(var_108.as_str());
}
if let Some(var_109) = &input.recommendation_provider_role_arn {
object
.key("RecommendationProviderRoleArn")
.string(var_109.as_str());
}
if let Some(var_110) = &input.recommendation_provider_uri {
object
.key("RecommendationProviderUri")
.string(var_110.as_str());
}
if let Some(var_111) = &input.recommendation_transformer_uri {
object
.key("RecommendationTransformerUri")
.string(var_111.as_str());
}
if let Some(var_112) = &input.recommendations_display_name {
object
.key("RecommendationsDisplayName")
.string(var_112.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::SerializationError> {
if let Some(var_113) = &input.dimensions {
let mut object_114 = object.key("Dimensions").start_object();
crate::json_ser::serialize_structure_crate_model_segment_dimensions(
&mut object_114,
var_113,
)?;
object_114.finish();
}
if let Some(var_115) = &input.name {
object.key("Name").string(var_115.as_str());
}
if let Some(var_116) = &input.segment_groups {
let mut object_117 = object.key("SegmentGroups").start_object();
crate::json_ser::serialize_structure_crate_model_segment_group_list(
&mut object_117,
var_116,
)?;
object_117.finish();
}
if let Some(var_118) = &input.tags {
let mut object_119 = object.key("tags").start_object();
for (key_120, value_121) in var_118 {
{
object_119.key(key_120).string(value_121.as_str());
}
}
object_119.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::SerializationError> {
if let Some(var_122) = &input.body {
object.key("Body").string(var_122.as_str());
}
if let Some(var_123) = &input.default_substitutions {
object.key("DefaultSubstitutions").string(var_123.as_str());
}
if let Some(var_124) = &input.recommender_id {
object.key("RecommenderId").string(var_124.as_str());
}
if let Some(var_125) = &input.tags {
let mut object_126 = object.key("tags").start_object();
for (key_127, value_128) in var_125 {
{
object_126.key(key_127).string(value_128.as_str());
}
}
object_126.finish();
}
if let Some(var_129) = &input.template_description {
object.key("TemplateDescription").string(var_129.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::SerializationError> {
if let Some(var_130) = &input.body {
object.key("Body").string(var_130.as_str());
}
if let Some(var_131) = &input.default_substitutions {
object.key("DefaultSubstitutions").string(var_131.as_str());
}
if let Some(var_132) = &input.language_code {
object.key("LanguageCode").string(var_132.as_str());
}
if let Some(var_133) = &input.tags {
let mut object_134 = object.key("tags").start_object();
for (key_135, value_136) in var_133 {
{
object_134.key(key_135).string(value_136.as_str());
}
}
object_134.finish();
}
if let Some(var_137) = &input.template_description {
object.key("TemplateDescription").string(var_137.as_str());
}
if let Some(var_138) = &input.voice_id {
object.key("VoiceId").string(var_138.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::SerializationError> {
if let Some(var_139) = &input.iso_country_code {
object.key("IsoCountryCode").string(var_139.as_str());
}
if let Some(var_140) = &input.phone_number {
object.key("PhoneNumber").string(var_140.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::SerializationError> {
if let Some(var_141) = &input.batch_item {
let mut object_142 = object.key("BatchItem").start_object();
for (key_143, value_144) in var_141 {
{
let mut object_145 = object_142.key(key_143).start_object();
crate::json_ser::serialize_structure_crate_model_events_batch(
&mut object_145,
value_144,
)?;
object_145.finish();
}
}
object_142.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::SerializationError> {
if let Some(var_146) = &input.destination_stream_arn {
object.key("DestinationStreamArn").string(var_146.as_str());
}
if let Some(var_147) = &input.role_arn {
object.key("RoleArn").string(var_147.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::SerializationError> {
if let Some(var_148) = &input.blacklist {
let mut array_149 = object.key("Blacklist").start_array();
for item_150 in var_148 {
{
array_149.value().string(item_150.as_str());
}
}
array_149.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::SerializationError> {
if let Some(var_151) = &input.addresses {
let mut object_152 = object.key("Addresses").start_object();
for (key_153, value_154) in var_151 {
{
let mut object_155 = object_152.key(key_153).start_object();
crate::json_ser::serialize_structure_crate_model_address_configuration(
&mut object_155,
value_154,
)?;
object_155.finish();
}
}
object_152.finish();
}
if let Some(var_156) = &input.context {
let mut object_157 = object.key("Context").start_object();
for (key_158, value_159) in var_156 {
{
object_157.key(key_158).string(value_159.as_str());
}
}
object_157.finish();
}
if let Some(var_160) = &input.endpoints {
let mut object_161 = object.key("Endpoints").start_object();
for (key_162, value_163) in var_160 {
{
let mut object_164 = object_161.key(key_162).start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_send_configuration(
&mut object_164,
value_163,
)?;
object_164.finish();
}
}
object_161.finish();
}
if let Some(var_165) = &input.message_configuration {
let mut object_166 = object.key("MessageConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_direct_message_configuration(
&mut object_166,
var_165,
)?;
object_166.finish();
}
if let Some(var_167) = &input.template_configuration {
let mut object_168 = object.key("TemplateConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_template_configuration(
&mut object_168,
var_167,
)?;
object_168.finish();
}
if let Some(var_169) = &input.trace_id {
object.key("TraceId").string(var_169.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::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_170) = &input.brand_name {
object.key("BrandName").string(var_170.as_str());
}
if let Some(var_171) = &input.channel {
object.key("Channel").string(var_171.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_172) = &input.destination_identity {
object.key("DestinationIdentity").string(var_172.as_str());
}
if let Some(var_173) = &input.entity_id {
object.key("EntityId").string(var_173.as_str());
}
if let Some(var_174) = &input.language {
object.key("Language").string(var_174.as_str());
}
if let Some(var_175) = &input.origination_identity {
object.key("OriginationIdentity").string(var_175.as_str());
}
if let Some(var_176) = &input.reference_id {
object.key("ReferenceId").string(var_176.as_str());
}
if let Some(var_177) = &input.template_id {
object.key("TemplateId").string(var_177.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::SerializationError> {
if let Some(var_178) = &input.context {
let mut object_179 = object.key("Context").start_object();
for (key_180, value_181) in var_178 {
{
object_179.key(key_180).string(value_181.as_str());
}
}
object_179.finish();
}
if let Some(var_182) = &input.message_configuration {
let mut object_183 = object.key("MessageConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_direct_message_configuration(
&mut object_183,
var_182,
)?;
object_183.finish();
}
if let Some(var_184) = &input.template_configuration {
let mut object_185 = object.key("TemplateConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_template_configuration(
&mut object_185,
var_184,
)?;
object_185.finish();
}
if let Some(var_186) = &input.trace_id {
object.key("TraceId").string(var_186.as_str());
}
if let Some(var_187) = &input.users {
let mut object_188 = object.key("Users").start_object();
for (key_189, value_190) in var_187 {
{
let mut object_191 = object_188.key(key_189).start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_send_configuration(
&mut object_191,
value_190,
)?;
object_191.finish();
}
}
object_188.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::SerializationError> {
if let Some(var_192) = &input.tags {
let mut object_193 = object.key("tags").start_object();
for (key_194, value_195) in var_192 {
{
object_193.key(key_194).string(value_195.as_str());
}
}
object_193.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::SerializationError> {
if let Some(var_196) = &input.client_id {
object.key("ClientId").string(var_196.as_str());
}
if let Some(var_197) = &input.client_secret {
object.key("ClientSecret").string(var_197.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::SerializationError> {
if let Some(var_198) = &input.bundle_id {
object.key("BundleId").string(var_198.as_str());
}
if let Some(var_199) = &input.certificate {
object.key("Certificate").string(var_199.as_str());
}
if let Some(var_200) = &input.default_authentication_method {
object
.key("DefaultAuthenticationMethod")
.string(var_200.as_str());
}
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_201) = &input.private_key {
object.key("PrivateKey").string(var_201.as_str());
}
if let Some(var_202) = &input.team_id {
object.key("TeamId").string(var_202.as_str());
}
if let Some(var_203) = &input.token_key {
object.key("TokenKey").string(var_203.as_str());
}
if let Some(var_204) = &input.token_key_id {
object.key("TokenKeyId").string(var_204.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::SerializationError> {
if let Some(var_205) = &input.bundle_id {
object.key("BundleId").string(var_205.as_str());
}
if let Some(var_206) = &input.certificate {
object.key("Certificate").string(var_206.as_str());
}
if let Some(var_207) = &input.default_authentication_method {
object
.key("DefaultAuthenticationMethod")
.string(var_207.as_str());
}
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_208) = &input.private_key {
object.key("PrivateKey").string(var_208.as_str());
}
if let Some(var_209) = &input.team_id {
object.key("TeamId").string(var_209.as_str());
}
if let Some(var_210) = &input.token_key {
object.key("TokenKey").string(var_210.as_str());
}
if let Some(var_211) = &input.token_key_id {
object.key("TokenKeyId").string(var_211.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::SerializationError> {
if let Some(var_212) = &input.bundle_id {
object.key("BundleId").string(var_212.as_str());
}
if let Some(var_213) = &input.certificate {
object.key("Certificate").string(var_213.as_str());
}
if let Some(var_214) = &input.default_authentication_method {
object
.key("DefaultAuthenticationMethod")
.string(var_214.as_str());
}
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_215) = &input.private_key {
object.key("PrivateKey").string(var_215.as_str());
}
if let Some(var_216) = &input.team_id {
object.key("TeamId").string(var_216.as_str());
}
if let Some(var_217) = &input.token_key {
object.key("TokenKey").string(var_217.as_str());
}
if let Some(var_218) = &input.token_key_id {
object.key("TokenKeyId").string(var_218.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::SerializationError> {
if let Some(var_219) = &input.bundle_id {
object.key("BundleId").string(var_219.as_str());
}
if let Some(var_220) = &input.certificate {
object.key("Certificate").string(var_220.as_str());
}
if let Some(var_221) = &input.default_authentication_method {
object
.key("DefaultAuthenticationMethod")
.string(var_221.as_str());
}
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_222) = &input.private_key {
object.key("PrivateKey").string(var_222.as_str());
}
if let Some(var_223) = &input.team_id {
object.key("TeamId").string(var_223.as_str());
}
if let Some(var_224) = &input.token_key {
object.key("TokenKey").string(var_224.as_str());
}
if let Some(var_225) = &input.token_key_id {
object.key("TokenKeyId").string(var_225.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::SerializationError> {
if let Some(var_226) = &input.campaign_hook {
let mut object_227 = object.key("CampaignHook").start_object();
crate::json_ser::serialize_structure_crate_model_campaign_hook(&mut object_227, var_226)?;
object_227.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_228) = &input.limits {
let mut object_229 = object.key("Limits").start_object();
crate::json_ser::serialize_structure_crate_model_campaign_limits(&mut object_229, var_228)?;
object_229.finish();
}
if let Some(var_230) = &input.quiet_time {
let mut object_231 = object.key("QuietTime").start_object();
crate::json_ser::serialize_structure_crate_model_quiet_time(&mut object_231, var_230)?;
object_231.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::SerializationError> {
if let Some(var_232) = &input.api_key {
object.key("ApiKey").string(var_232.as_str());
}
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_233) = &input.secret_key {
object.key("SecretKey").string(var_233.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::SerializationError> {
if let Some(var_234) = &input.configuration_set {
object.key("ConfigurationSet").string(var_234.as_str());
}
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_235) = &input.from_address {
object.key("FromAddress").string(var_235.as_str());
}
if let Some(var_236) = &input.identity {
object.key("Identity").string(var_236.as_str());
}
if let Some(var_237) = &input.role_arn {
object.key("RoleArn").string(var_237.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::SerializationError> {
if let Some(var_238) = &input.address {
object.key("Address").string(var_238.as_str());
}
if let Some(var_239) = &input.attributes {
let mut object_240 = object.key("Attributes").start_object();
for (key_241, value_242) in var_239 {
{
let mut array_243 = object_240.key(key_241).start_array();
for item_244 in value_242 {
{
array_243.value().string(item_244.as_str());
}
}
array_243.finish();
}
}
object_240.finish();
}
if let Some(var_245) = &input.channel_type {
object.key("ChannelType").string(var_245.as_str());
}
if let Some(var_246) = &input.demographic {
let mut object_247 = object.key("Demographic").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_demographic(
&mut object_247,
var_246,
)?;
object_247.finish();
}
if let Some(var_248) = &input.effective_date {
object.key("EffectiveDate").string(var_248.as_str());
}
if let Some(var_249) = &input.endpoint_status {
object.key("EndpointStatus").string(var_249.as_str());
}
if let Some(var_250) = &input.location {
let mut object_251 = object.key("Location").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_location(
&mut object_251,
var_250,
)?;
object_251.finish();
}
if let Some(var_252) = &input.metrics {
let mut object_253 = object.key("Metrics").start_object();
for (key_254, value_255) in var_252 {
{
object_253.key(key_254).number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*value_255).into()),
);
}
}
object_253.finish();
}
if let Some(var_256) = &input.opt_out {
object.key("OptOut").string(var_256.as_str());
}
if let Some(var_257) = &input.request_id {
object.key("RequestId").string(var_257.as_str());
}
if let Some(var_258) = &input.user {
let mut object_259 = object.key("User").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_user(&mut object_259, var_258)?;
object_259.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::SerializationError> {
if let Some(var_260) = &input.item {
let mut array_261 = object.key("Item").start_array();
for item_262 in var_260 {
{
let mut object_263 = array_261.value().start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_batch_item(
&mut object_263,
item_262,
)?;
object_263.finish();
}
}
array_261.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::SerializationError> {
if let Some(var_264) = &input.api_key {
object.key("ApiKey").string(var_264.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::SerializationError> {
if let Some(var_265) = &input.state {
object.key("State").string(var_265.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::SerializationError> {
if let Some(var_266) = &input.attributes {
let mut object_267 = object.key("Attributes").start_object();
for (key_268, value_269) in var_266 {
{
object_267.key(key_268).string(value_269.as_str());
}
}
object_267.finish();
}
if let Some(var_270) = &input.description {
object.key("Description").string(var_270.as_str());
}
if let Some(var_271) = &input.name {
object.key("Name").string(var_271.as_str());
}
if let Some(var_272) = &input.recommendation_provider_id_type {
object
.key("RecommendationProviderIdType")
.string(var_272.as_str());
}
if let Some(var_273) = &input.recommendation_provider_role_arn {
object
.key("RecommendationProviderRoleArn")
.string(var_273.as_str());
}
if let Some(var_274) = &input.recommendation_provider_uri {
object
.key("RecommendationProviderUri")
.string(var_274.as_str());
}
if let Some(var_275) = &input.recommendation_transformer_uri {
object
.key("RecommendationTransformerUri")
.string(var_275.as_str());
}
if let Some(var_276) = &input.recommendations_display_name {
object
.key("RecommendationsDisplayName")
.string(var_276.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::SerializationError> {
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_277) = &input.sender_id {
object.key("SenderId").string(var_277.as_str());
}
if let Some(var_278) = &input.short_code {
object.key("ShortCode").string(var_278.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::SerializationError> {
if let Some(var_279) = &input.version {
object.key("Version").string(var_279.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::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::SerializationError> {
if let Some(var_280) = &input.destination_identity {
object.key("DestinationIdentity").string(var_280.as_str());
}
if let Some(var_281) = &input.otp {
object.key("Otp").string(var_281.as_str());
}
if let Some(var_282) = &input.reference_id {
object.key("ReferenceId").string(var_282.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::SerializationError> {
if let Some(var_283) = &input.custom_delivery_configuration {
let mut object_284 = object.key("CustomDeliveryConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_custom_delivery_configuration(
&mut object_284,
var_283,
)?;
object_284.finish();
}
if let Some(var_285) = &input.message_configuration {
let mut object_286 = object.key("MessageConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_message_configuration(
&mut object_286,
var_285,
)?;
object_286.finish();
}
if let Some(var_287) = &input.schedule {
let mut object_288 = object.key("Schedule").start_object();
crate::json_ser::serialize_structure_crate_model_schedule(&mut object_288, var_287)?;
object_288.finish();
}
{
object.key("SizePercent").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.size_percent).into()),
);
}
if let Some(var_289) = &input.template_configuration {
let mut object_290 = object.key("TemplateConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_template_configuration(
&mut object_290,
var_289,
)?;
object_290.finish();
}
if let Some(var_291) = &input.treatment_description {
object.key("TreatmentDescription").string(var_291.as_str());
}
if let Some(var_292) = &input.treatment_name {
object.key("TreatmentName").string(var_292.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::SerializationError> {
if let Some(var_293) = &input.delivery_uri {
object.key("DeliveryUri").string(var_293.as_str());
}
if let Some(var_294) = &input.endpoint_types {
let mut array_295 = object.key("EndpointTypes").start_array();
for item_296 in var_294 {
{
array_295.value().string(item_296.as_str());
}
}
array_295.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::SerializationError> {
if let Some(var_297) = &input.lambda_function_name {
object.key("LambdaFunctionName").string(var_297.as_str());
}
if let Some(var_298) = &input.mode {
object.key("Mode").string(var_298.as_str());
}
if let Some(var_299) = &input.web_url {
object.key("WebUrl").string(var_299.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::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::SerializationError> {
if let Some(var_300) = &input.adm_message {
let mut object_301 = object.key("ADMMessage").start_object();
crate::json_ser::serialize_structure_crate_model_message(&mut object_301, var_300)?;
object_301.finish();
}
if let Some(var_302) = &input.apns_message {
let mut object_303 = object.key("APNSMessage").start_object();
crate::json_ser::serialize_structure_crate_model_message(&mut object_303, var_302)?;
object_303.finish();
}
if let Some(var_304) = &input.baidu_message {
let mut object_305 = object.key("BaiduMessage").start_object();
crate::json_ser::serialize_structure_crate_model_message(&mut object_305, var_304)?;
object_305.finish();
}
if let Some(var_306) = &input.custom_message {
let mut object_307 = object.key("CustomMessage").start_object();
crate::json_ser::serialize_structure_crate_model_campaign_custom_message(
&mut object_307,
var_306,
)?;
object_307.finish();
}
if let Some(var_308) = &input.default_message {
let mut object_309 = object.key("DefaultMessage").start_object();
crate::json_ser::serialize_structure_crate_model_message(&mut object_309, var_308)?;
object_309.finish();
}
if let Some(var_310) = &input.email_message {
let mut object_311 = object.key("EmailMessage").start_object();
crate::json_ser::serialize_structure_crate_model_campaign_email_message(
&mut object_311,
var_310,
)?;
object_311.finish();
}
if let Some(var_312) = &input.gcm_message {
let mut object_313 = object.key("GCMMessage").start_object();
crate::json_ser::serialize_structure_crate_model_message(&mut object_313, var_312)?;
object_313.finish();
}
if let Some(var_314) = &input.sms_message {
let mut object_315 = object.key("SMSMessage").start_object();
crate::json_ser::serialize_structure_crate_model_campaign_sms_message(
&mut object_315,
var_314,
)?;
object_315.finish();
}
if let Some(var_316) = &input.in_app_message {
let mut object_317 = object.key("InAppMessage").start_object();
crate::json_ser::serialize_structure_crate_model_campaign_in_app_message(
&mut object_317,
var_316,
)?;
object_317.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::SerializationError> {
if let Some(var_318) = &input.end_time {
object.key("EndTime").string(var_318.as_str());
}
if let Some(var_319) = &input.event_filter {
let mut object_320 = object.key("EventFilter").start_object();
crate::json_ser::serialize_structure_crate_model_campaign_event_filter(
&mut object_320,
var_319,
)?;
object_320.finish();
}
if let Some(var_321) = &input.frequency {
object.key("Frequency").string(var_321.as_str());
}
if input.is_local_time {
object.key("IsLocalTime").boolean(input.is_local_time);
}
if let Some(var_322) = &input.quiet_time {
let mut object_323 = object.key("QuietTime").start_object();
crate::json_ser::serialize_structure_crate_model_quiet_time(&mut object_323, var_322)?;
object_323.finish();
}
if let Some(var_324) = &input.start_time {
object.key("StartTime").string(var_324.as_str());
}
if let Some(var_325) = &input.timezone {
object.key("Timezone").string(var_325.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::SerializationError> {
if let Some(var_326) = &input.email_template {
let mut object_327 = object.key("EmailTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_template(&mut object_327, var_326)?;
object_327.finish();
}
if let Some(var_328) = &input.push_template {
let mut object_329 = object.key("PushTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_template(&mut object_329, var_328)?;
object_329.finish();
}
if let Some(var_330) = &input.sms_template {
let mut object_331 = object.key("SMSTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_template(&mut object_331, var_330)?;
object_331.finish();
}
if let Some(var_332) = &input.voice_template {
let mut object_333 = object.key("VoiceTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_template(&mut object_333, var_332)?;
object_333.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::SerializationError> {
if let Some(var_334) = &input.background_color {
object.key("BackgroundColor").string(var_334.as_str());
}
if let Some(var_335) = &input.body_config {
let mut object_336 = object.key("BodyConfig").start_object();
crate::json_ser::serialize_structure_crate_model_in_app_message_body_config(
&mut object_336,
var_335,
)?;
object_336.finish();
}
if let Some(var_337) = &input.header_config {
let mut object_338 = object.key("HeaderConfig").start_object();
crate::json_ser::serialize_structure_crate_model_in_app_message_header_config(
&mut object_338,
var_337,
)?;
object_338.finish();
}
if let Some(var_339) = &input.image_url {
object.key("ImageUrl").string(var_339.as_str());
}
if let Some(var_340) = &input.primary_btn {
let mut object_341 = object.key("PrimaryBtn").start_object();
crate::json_ser::serialize_structure_crate_model_in_app_message_button(
&mut object_341,
var_340,
)?;
object_341.finish();
}
if let Some(var_342) = &input.secondary_btn {
let mut object_343 = object.key("SecondaryBtn").start_object();
crate::json_ser::serialize_structure_crate_model_in_app_message_button(
&mut object_343,
var_342,
)?;
object_343.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::SerializationError> {
if let Some(var_344) = &input.custom {
let mut object_345 = object.key("CUSTOM").start_object();
crate::json_ser::serialize_structure_crate_model_custom_message_activity(
&mut object_345,
var_344,
)?;
object_345.finish();
}
if let Some(var_346) = &input.conditional_split {
let mut object_347 = object.key("ConditionalSplit").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_split_activity(
&mut object_347,
var_346,
)?;
object_347.finish();
}
if let Some(var_348) = &input.description {
object.key("Description").string(var_348.as_str());
}
if let Some(var_349) = &input.email {
let mut object_350 = object.key("EMAIL").start_object();
crate::json_ser::serialize_structure_crate_model_email_message_activity(
&mut object_350,
var_349,
)?;
object_350.finish();
}
if let Some(var_351) = &input.holdout {
let mut object_352 = object.key("Holdout").start_object();
crate::json_ser::serialize_structure_crate_model_holdout_activity(
&mut object_352,
var_351,
)?;
object_352.finish();
}
if let Some(var_353) = &input.multi_condition {
let mut object_354 = object.key("MultiCondition").start_object();
crate::json_ser::serialize_structure_crate_model_multi_conditional_split_activity(
&mut object_354,
var_353,
)?;
object_354.finish();
}
if let Some(var_355) = &input.push {
let mut object_356 = object.key("PUSH").start_object();
crate::json_ser::serialize_structure_crate_model_push_message_activity(
&mut object_356,
var_355,
)?;
object_356.finish();
}
if let Some(var_357) = &input.random_split {
let mut object_358 = object.key("RandomSplit").start_object();
crate::json_ser::serialize_structure_crate_model_random_split_activity(
&mut object_358,
var_357,
)?;
object_358.finish();
}
if let Some(var_359) = &input.sms {
let mut object_360 = object.key("SMS").start_object();
crate::json_ser::serialize_structure_crate_model_sms_message_activity(
&mut object_360,
var_359,
)?;
object_360.finish();
}
if let Some(var_361) = &input.wait {
let mut object_362 = object.key("Wait").start_object();
crate::json_ser::serialize_structure_crate_model_wait_activity(&mut object_362, var_361)?;
object_362.finish();
}
if let Some(var_363) = &input.contact_center {
let mut object_364 = object.key("ContactCenter").start_object();
crate::json_ser::serialize_structure_crate_model_contact_center_activity(
&mut object_364,
var_363,
)?;
object_364.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::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_365) = &input.endpoint_reentry_interval {
object
.key("EndpointReentryInterval")
.string(var_365.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::SerializationError> {
if let Some(var_366) = &input.end {
object.key("End").string(var_366.as_str());
}
if let Some(var_367) = &input.start {
object.key("Start").string(var_367.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::SerializationError> {
if let Some(var_368) = &input.end_time {
object
.key("EndTime")
.date_time(var_368, aws_smithy_types::date_time::Format::DateTime)?;
}
if let Some(var_369) = &input.start_time {
object
.key("StartTime")
.date_time(var_369, aws_smithy_types::date_time::Format::DateTime)?;
}
if let Some(var_370) = &input.timezone {
object.key("Timezone").string(var_370.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::SerializationError> {
if let Some(var_371) = &input.description {
object.key("Description").string(var_371.as_str());
}
if let Some(var_372) = &input.event_start_condition {
let mut object_373 = object.key("EventStartCondition").start_object();
crate::json_ser::serialize_structure_crate_model_event_start_condition(
&mut object_373,
var_372,
)?;
object_373.finish();
}
if let Some(var_374) = &input.segment_start_condition {
let mut object_375 = object.key("SegmentStartCondition").start_object();
crate::json_ser::serialize_structure_crate_model_segment_condition(
&mut object_375,
var_374,
)?;
object_375.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::SerializationError> {
if let Some(var_376) = &input.connect_campaign_arn {
object.key("ConnectCampaignArn").string(var_376.as_str());
}
if let Some(var_377) = &input.connect_campaign_execution_role_arn {
object
.key("ConnectCampaignExecutionRoleArn")
.string(var_377.as_str());
}
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::SerializationError> {
if let Some(var_378) = &input.action {
object.key("Action").string(var_378.as_str());
}
if let Some(var_379) = &input.body {
object.key("Body").string(var_379.as_str());
}
if let Some(var_380) = &input.image_icon_url {
object.key("ImageIconUrl").string(var_380.as_str());
}
if let Some(var_381) = &input.image_url {
object.key("ImageUrl").string(var_381.as_str());
}
if let Some(var_382) = &input.raw_content {
object.key("RawContent").string(var_382.as_str());
}
if let Some(var_383) = &input.small_image_icon_url {
object.key("SmallImageIconUrl").string(var_383.as_str());
}
if let Some(var_384) = &input.sound {
object.key("Sound").string(var_384.as_str());
}
if let Some(var_385) = &input.title {
object.key("Title").string(var_385.as_str());
}
if let Some(var_386) = &input.url {
object.key("Url").string(var_386.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::SerializationError> {
if let Some(var_387) = &input.action {
object.key("Action").string(var_387.as_str());
}
if let Some(var_388) = &input.body {
object.key("Body").string(var_388.as_str());
}
if let Some(var_389) = &input.media_url {
object.key("MediaUrl").string(var_389.as_str());
}
if let Some(var_390) = &input.raw_content {
object.key("RawContent").string(var_390.as_str());
}
if let Some(var_391) = &input.sound {
object.key("Sound").string(var_391.as_str());
}
if let Some(var_392) = &input.title {
object.key("Title").string(var_392.as_str());
}
if let Some(var_393) = &input.url {
object.key("Url").string(var_393.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::SerializationError> {
if let Some(var_394) = &input.action {
object.key("Action").string(var_394.as_str());
}
if let Some(var_395) = &input.body {
object.key("Body").string(var_395.as_str());
}
if let Some(var_396) = &input.sound {
object.key("Sound").string(var_396.as_str());
}
if let Some(var_397) = &input.title {
object.key("Title").string(var_397.as_str());
}
if let Some(var_398) = &input.url {
object.key("Url").string(var_398.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::SerializationError> {
if let Some(var_399) = &input.attributes {
let mut object_400 = object.key("Attributes").start_object();
for (key_401, value_402) in var_399 {
{
let mut object_403 = object_400.key(key_401).start_object();
crate::json_ser::serialize_structure_crate_model_attribute_dimension(
&mut object_403,
value_402,
)?;
object_403.finish();
}
}
object_400.finish();
}
if let Some(var_404) = &input.behavior {
let mut object_405 = object.key("Behavior").start_object();
crate::json_ser::serialize_structure_crate_model_segment_behaviors(
&mut object_405,
var_404,
)?;
object_405.finish();
}
if let Some(var_406) = &input.demographic {
let mut object_407 = object.key("Demographic").start_object();
crate::json_ser::serialize_structure_crate_model_segment_demographics(
&mut object_407,
var_406,
)?;
object_407.finish();
}
if let Some(var_408) = &input.location {
let mut object_409 = object.key("Location").start_object();
crate::json_ser::serialize_structure_crate_model_segment_location(
&mut object_409,
var_408,
)?;
object_409.finish();
}
if let Some(var_410) = &input.metrics {
let mut object_411 = object.key("Metrics").start_object();
for (key_412, value_413) in var_410 {
{
let mut object_414 = object_411.key(key_412).start_object();
crate::json_ser::serialize_structure_crate_model_metric_dimension(
&mut object_414,
value_413,
)?;
object_414.finish();
}
}
object_411.finish();
}
if let Some(var_415) = &input.user_attributes {
let mut object_416 = object.key("UserAttributes").start_object();
for (key_417, value_418) in var_415 {
{
let mut object_419 = object_416.key(key_417).start_object();
crate::json_ser::serialize_structure_crate_model_attribute_dimension(
&mut object_419,
value_418,
)?;
object_419.finish();
}
}
object_416.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::SerializationError> {
if let Some(var_420) = &input.groups {
let mut array_421 = object.key("Groups").start_array();
for item_422 in var_420 {
{
let mut object_423 = array_421.value().start_object();
crate::json_ser::serialize_structure_crate_model_segment_group(
&mut object_423,
item_422,
)?;
object_423.finish();
}
}
array_421.finish();
}
if let Some(var_424) = &input.include {
object.key("Include").string(var_424.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::SerializationError> {
if let Some(var_425) = &input.endpoint {
let mut object_426 = object.key("Endpoint").start_object();
crate::json_ser::serialize_structure_crate_model_public_endpoint(&mut object_426, var_425)?;
object_426.finish();
}
if let Some(var_427) = &input.events {
let mut object_428 = object.key("Events").start_object();
for (key_429, value_430) in var_427 {
{
let mut object_431 = object_428.key(key_429).start_object();
crate::json_ser::serialize_structure_crate_model_event(&mut object_431, value_430)?;
object_431.finish();
}
}
object_428.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::SerializationError> {
if let Some(var_432) = &input.body_override {
object.key("BodyOverride").string(var_432.as_str());
}
if let Some(var_433) = &input.channel_type {
object.key("ChannelType").string(var_433.as_str());
}
if let Some(var_434) = &input.context {
let mut object_435 = object.key("Context").start_object();
for (key_436, value_437) in var_434 {
{
object_435.key(key_436).string(value_437.as_str());
}
}
object_435.finish();
}
if let Some(var_438) = &input.raw_content {
object.key("RawContent").string(var_438.as_str());
}
if let Some(var_439) = &input.substitutions {
let mut object_440 = object.key("Substitutions").start_object();
for (key_441, value_442) in var_439 {
{
let mut array_443 = object_440.key(key_441).start_array();
for item_444 in value_442 {
{
array_443.value().string(item_444.as_str());
}
}
array_443.finish();
}
}
object_440.finish();
}
if let Some(var_445) = &input.title_override {
object.key("TitleOverride").string(var_445.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::SerializationError> {
if let Some(var_446) = &input.body_override {
object.key("BodyOverride").string(var_446.as_str());
}
if let Some(var_447) = &input.context {
let mut object_448 = object.key("Context").start_object();
for (key_449, value_450) in var_447 {
{
object_448.key(key_449).string(value_450.as_str());
}
}
object_448.finish();
}
if let Some(var_451) = &input.raw_content {
object.key("RawContent").string(var_451.as_str());
}
if let Some(var_452) = &input.substitutions {
let mut object_453 = object.key("Substitutions").start_object();
for (key_454, value_455) in var_452 {
{
let mut array_456 = object_453.key(key_454).start_array();
for item_457 in value_455 {
{
array_456.value().string(item_457.as_str());
}
}
array_456.finish();
}
}
object_453.finish();
}
if let Some(var_458) = &input.title_override {
object.key("TitleOverride").string(var_458.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::SerializationError> {
if let Some(var_459) = &input.adm_message {
let mut object_460 = object.key("ADMMessage").start_object();
crate::json_ser::serialize_structure_crate_model_adm_message(&mut object_460, var_459)?;
object_460.finish();
}
if let Some(var_461) = &input.apns_message {
let mut object_462 = object.key("APNSMessage").start_object();
crate::json_ser::serialize_structure_crate_model_apns_message(&mut object_462, var_461)?;
object_462.finish();
}
if let Some(var_463) = &input.baidu_message {
let mut object_464 = object.key("BaiduMessage").start_object();
crate::json_ser::serialize_structure_crate_model_baidu_message(&mut object_464, var_463)?;
object_464.finish();
}
if let Some(var_465) = &input.default_message {
let mut object_466 = object.key("DefaultMessage").start_object();
crate::json_ser::serialize_structure_crate_model_default_message(&mut object_466, var_465)?;
object_466.finish();
}
if let Some(var_467) = &input.default_push_notification_message {
let mut object_468 = object.key("DefaultPushNotificationMessage").start_object();
crate::json_ser::serialize_structure_crate_model_default_push_notification_message(
&mut object_468,
var_467,
)?;
object_468.finish();
}
if let Some(var_469) = &input.email_message {
let mut object_470 = object.key("EmailMessage").start_object();
crate::json_ser::serialize_structure_crate_model_email_message(&mut object_470, var_469)?;
object_470.finish();
}
if let Some(var_471) = &input.gcm_message {
let mut object_472 = object.key("GCMMessage").start_object();
crate::json_ser::serialize_structure_crate_model_gcm_message(&mut object_472, var_471)?;
object_472.finish();
}
if let Some(var_473) = &input.sms_message {
let mut object_474 = object.key("SMSMessage").start_object();
crate::json_ser::serialize_structure_crate_model_sms_message(&mut object_474, var_473)?;
object_474.finish();
}
if let Some(var_475) = &input.voice_message {
let mut object_476 = object.key("VoiceMessage").start_object();
crate::json_ser::serialize_structure_crate_model_voice_message(&mut object_476, var_475)?;
object_476.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::SerializationError> {
if let Some(var_477) = &input.app_version {
object.key("AppVersion").string(var_477.as_str());
}
if let Some(var_478) = &input.locale {
object.key("Locale").string(var_478.as_str());
}
if let Some(var_479) = &input.make {
object.key("Make").string(var_479.as_str());
}
if let Some(var_480) = &input.model {
object.key("Model").string(var_480.as_str());
}
if let Some(var_481) = &input.model_version {
object.key("ModelVersion").string(var_481.as_str());
}
if let Some(var_482) = &input.platform {
object.key("Platform").string(var_482.as_str());
}
if let Some(var_483) = &input.platform_version {
object.key("PlatformVersion").string(var_483.as_str());
}
if let Some(var_484) = &input.timezone {
object.key("Timezone").string(var_484.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::SerializationError> {
if let Some(var_485) = &input.city {
object.key("City").string(var_485.as_str());
}
if let Some(var_486) = &input.country {
object.key("Country").string(var_486.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_487) = &input.postal_code {
object.key("PostalCode").string(var_487.as_str());
}
if let Some(var_488) = &input.region {
object.key("Region").string(var_488.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::SerializationError> {
if let Some(var_489) = &input.user_attributes {
let mut object_490 = object.key("UserAttributes").start_object();
for (key_491, value_492) in var_489 {
{
let mut array_493 = object_490.key(key_491).start_array();
for item_494 in value_492 {
{
array_493.value().string(item_494.as_str());
}
}
array_493.finish();
}
}
object_490.finish();
}
if let Some(var_495) = &input.user_id {
object.key("UserId").string(var_495.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::SerializationError> {
if let Some(var_496) = &input.address {
object.key("Address").string(var_496.as_str());
}
if let Some(var_497) = &input.attributes {
let mut object_498 = object.key("Attributes").start_object();
for (key_499, value_500) in var_497 {
{
let mut array_501 = object_498.key(key_499).start_array();
for item_502 in value_500 {
{
array_501.value().string(item_502.as_str());
}
}
array_501.finish();
}
}
object_498.finish();
}
if let Some(var_503) = &input.channel_type {
object.key("ChannelType").string(var_503.as_str());
}
if let Some(var_504) = &input.demographic {
let mut object_505 = object.key("Demographic").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_demographic(
&mut object_505,
var_504,
)?;
object_505.finish();
}
if let Some(var_506) = &input.effective_date {
object.key("EffectiveDate").string(var_506.as_str());
}
if let Some(var_507) = &input.endpoint_status {
object.key("EndpointStatus").string(var_507.as_str());
}
if let Some(var_508) = &input.id {
object.key("Id").string(var_508.as_str());
}
if let Some(var_509) = &input.location {
let mut object_510 = object.key("Location").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_location(
&mut object_510,
var_509,
)?;
object_510.finish();
}
if let Some(var_511) = &input.metrics {
let mut object_512 = object.key("Metrics").start_object();
for (key_513, value_514) in var_511 {
{
object_512.key(key_513).number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*value_514).into()),
);
}
}
object_512.finish();
}
if let Some(var_515) = &input.opt_out {
object.key("OptOut").string(var_515.as_str());
}
if let Some(var_516) = &input.request_id {
object.key("RequestId").string(var_516.as_str());
}
if let Some(var_517) = &input.user {
let mut object_518 = object.key("User").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_user(&mut object_518, var_517)?;
object_518.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::SerializationError> {
if let Some(var_519) = &input.action {
object.key("Action").string(var_519.as_str());
}
if let Some(var_520) = &input.body {
object.key("Body").string(var_520.as_str());
}
if let Some(var_521) = &input.image_icon_url {
object.key("ImageIconUrl").string(var_521.as_str());
}
if let Some(var_522) = &input.image_small_icon_url {
object.key("ImageSmallIconUrl").string(var_522.as_str());
}
if let Some(var_523) = &input.image_url {
object.key("ImageUrl").string(var_523.as_str());
}
if let Some(var_524) = &input.json_body {
object.key("JsonBody").string(var_524.as_str());
}
if let Some(var_525) = &input.media_url {
object.key("MediaUrl").string(var_525.as_str());
}
if let Some(var_526) = &input.raw_content {
object.key("RawContent").string(var_526.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_527) = &input.title {
object.key("Title").string(var_527.as_str());
}
if let Some(var_528) = &input.url {
object.key("Url").string(var_528.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::SerializationError> {
if let Some(var_529) = &input.data {
object.key("Data").string(var_529.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::SerializationError> {
if let Some(var_530) = &input.body {
object.key("Body").string(var_530.as_str());
}
if let Some(var_531) = &input.from_address {
object.key("FromAddress").string(var_531.as_str());
}
if let Some(var_532) = &input.html_body {
object.key("HtmlBody").string(var_532.as_str());
}
if let Some(var_533) = &input.title {
object.key("Title").string(var_533.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::SerializationError> {
if let Some(var_534) = &input.body {
object.key("Body").string(var_534.as_str());
}
if let Some(var_535) = &input.message_type {
object.key("MessageType").string(var_535.as_str());
}
if let Some(var_536) = &input.origination_number {
object.key("OriginationNumber").string(var_536.as_str());
}
if let Some(var_537) = &input.sender_id {
object.key("SenderId").string(var_537.as_str());
}
if let Some(var_538) = &input.entity_id {
object.key("EntityId").string(var_538.as_str());
}
if let Some(var_539) = &input.template_id {
object.key("TemplateId").string(var_539.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::SerializationError> {
if let Some(var_540) = &input.body {
object.key("Body").string(var_540.as_str());
}
if let Some(var_541) = &input.content {
let mut array_542 = object.key("Content").start_array();
for item_543 in var_541 {
{
let mut object_544 = array_542.value().start_object();
crate::json_ser::serialize_structure_crate_model_in_app_message_content(
&mut object_544,
item_543,
)?;
object_544.finish();
}
}
array_542.finish();
}
if let Some(var_545) = &input.custom_config {
let mut object_546 = object.key("CustomConfig").start_object();
for (key_547, value_548) in var_545 {
{
object_546.key(key_547).string(value_548.as_str());
}
}
object_546.finish();
}
if let Some(var_549) = &input.layout {
object.key("Layout").string(var_549.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::SerializationError> {
if let Some(var_550) = &input.dimensions {
let mut object_551 = object.key("Dimensions").start_object();
crate::json_ser::serialize_structure_crate_model_event_dimensions(
&mut object_551,
var_550,
)?;
object_551.finish();
}
if let Some(var_552) = &input.filter_type {
object.key("FilterType").string(var_552.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::SerializationError> {
if let Some(var_553) = &input.name {
object.key("Name").string(var_553.as_str());
}
if let Some(var_554) = &input.version {
object.key("Version").string(var_554.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::SerializationError> {
if let Some(var_555) = &input.alignment {
object.key("Alignment").string(var_555.as_str());
}
if let Some(var_556) = &input.body {
object.key("Body").string(var_556.as_str());
}
if let Some(var_557) = &input.text_color {
object.key("TextColor").string(var_557.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::SerializationError> {
if let Some(var_558) = &input.alignment {
object.key("Alignment").string(var_558.as_str());
}
if let Some(var_559) = &input.header {
object.key("Header").string(var_559.as_str());
}
if let Some(var_560) = &input.text_color {
object.key("TextColor").string(var_560.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::SerializationError> {
if let Some(var_561) = &input.android {
let mut object_562 = object.key("Android").start_object();
crate::json_ser::serialize_structure_crate_model_override_button_configuration(
&mut object_562,
var_561,
)?;
object_562.finish();
}
if let Some(var_563) = &input.default_config {
let mut object_564 = object.key("DefaultConfig").start_object();
crate::json_ser::serialize_structure_crate_model_default_button_configuration(
&mut object_564,
var_563,
)?;
object_564.finish();
}
if let Some(var_565) = &input.ios {
let mut object_566 = object.key("IOS").start_object();
crate::json_ser::serialize_structure_crate_model_override_button_configuration(
&mut object_566,
var_565,
)?;
object_566.finish();
}
if let Some(var_567) = &input.web {
let mut object_568 = object.key("Web").start_object();
crate::json_ser::serialize_structure_crate_model_override_button_configuration(
&mut object_568,
var_567,
)?;
object_568.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::SerializationError> {
if let Some(var_569) = &input.delivery_uri {
object.key("DeliveryUri").string(var_569.as_str());
}
if let Some(var_570) = &input.endpoint_types {
let mut array_571 = object.key("EndpointTypes").start_array();
for item_572 in var_570 {
{
array_571.value().string(item_572.as_str());
}
}
array_571.finish();
}
if let Some(var_573) = &input.message_config {
let mut object_574 = object.key("MessageConfig").start_object();
crate::json_ser::serialize_structure_crate_model_journey_custom_message(
&mut object_574,
var_573,
)?;
object_574.finish();
}
if let Some(var_575) = &input.next_activity {
object.key("NextActivity").string(var_575.as_str());
}
if let Some(var_576) = &input.template_name {
object.key("TemplateName").string(var_576.as_str());
}
if let Some(var_577) = &input.template_version {
object.key("TemplateVersion").string(var_577.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::SerializationError> {
if let Some(var_578) = &input.condition {
let mut object_579 = object.key("Condition").start_object();
crate::json_ser::serialize_structure_crate_model_condition(&mut object_579, var_578)?;
object_579.finish();
}
if let Some(var_580) = &input.evaluation_wait_time {
let mut object_581 = object.key("EvaluationWaitTime").start_object();
crate::json_ser::serialize_structure_crate_model_wait_time(&mut object_581, var_580)?;
object_581.finish();
}
if let Some(var_582) = &input.false_activity {
object.key("FalseActivity").string(var_582.as_str());
}
if let Some(var_583) = &input.true_activity {
object.key("TrueActivity").string(var_583.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::SerializationError> {
if let Some(var_584) = &input.message_config {
let mut object_585 = object.key("MessageConfig").start_object();
crate::json_ser::serialize_structure_crate_model_journey_email_message(
&mut object_585,
var_584,
)?;
object_585.finish();
}
if let Some(var_586) = &input.next_activity {
object.key("NextActivity").string(var_586.as_str());
}
if let Some(var_587) = &input.template_name {
object.key("TemplateName").string(var_587.as_str());
}
if let Some(var_588) = &input.template_version {
object.key("TemplateVersion").string(var_588.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::SerializationError> {
if let Some(var_589) = &input.next_activity {
object.key("NextActivity").string(var_589.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::SerializationError> {
if let Some(var_590) = &input.branches {
let mut array_591 = object.key("Branches").start_array();
for item_592 in var_590 {
{
let mut object_593 = array_591.value().start_object();
crate::json_ser::serialize_structure_crate_model_multi_conditional_branch(
&mut object_593,
item_592,
)?;
object_593.finish();
}
}
array_591.finish();
}
if let Some(var_594) = &input.default_activity {
object.key("DefaultActivity").string(var_594.as_str());
}
if let Some(var_595) = &input.evaluation_wait_time {
let mut object_596 = object.key("EvaluationWaitTime").start_object();
crate::json_ser::serialize_structure_crate_model_wait_time(&mut object_596, var_595)?;
object_596.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::SerializationError> {
if let Some(var_597) = &input.message_config {
let mut object_598 = object.key("MessageConfig").start_object();
crate::json_ser::serialize_structure_crate_model_journey_push_message(
&mut object_598,
var_597,
)?;
object_598.finish();
}
if let Some(var_599) = &input.next_activity {
object.key("NextActivity").string(var_599.as_str());
}
if let Some(var_600) = &input.template_name {
object.key("TemplateName").string(var_600.as_str());
}
if let Some(var_601) = &input.template_version {
object.key("TemplateVersion").string(var_601.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::SerializationError> {
if let Some(var_602) = &input.branches {
let mut array_603 = object.key("Branches").start_array();
for item_604 in var_602 {
{
let mut object_605 = array_603.value().start_object();
crate::json_ser::serialize_structure_crate_model_random_split_entry(
&mut object_605,
item_604,
)?;
object_605.finish();
}
}
array_603.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::SerializationError> {
if let Some(var_606) = &input.message_config {
let mut object_607 = object.key("MessageConfig").start_object();
crate::json_ser::serialize_structure_crate_model_journey_sms_message(
&mut object_607,
var_606,
)?;
object_607.finish();
}
if let Some(var_608) = &input.next_activity {
object.key("NextActivity").string(var_608.as_str());
}
if let Some(var_609) = &input.template_name {
object.key("TemplateName").string(var_609.as_str());
}
if let Some(var_610) = &input.template_version {
object.key("TemplateVersion").string(var_610.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::SerializationError> {
if let Some(var_611) = &input.next_activity {
object.key("NextActivity").string(var_611.as_str());
}
if let Some(var_612) = &input.wait_time {
let mut object_613 = object.key("WaitTime").start_object();
crate::json_ser::serialize_structure_crate_model_wait_time(&mut object_613, var_612)?;
object_613.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::SerializationError> {
if let Some(var_614) = &input.next_activity {
object.key("NextActivity").string(var_614.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::SerializationError> {
if let Some(var_615) = &input.event_filter {
let mut object_616 = object.key("EventFilter").start_object();
crate::json_ser::serialize_structure_crate_model_event_filter(&mut object_616, var_615)?;
object_616.finish();
}
if let Some(var_617) = &input.segment_id {
object.key("SegmentId").string(var_617.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::SerializationError> {
if let Some(var_618) = &input.segment_id {
object.key("SegmentId").string(var_618.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::SerializationError> {
if let Some(var_619) = &input.attribute_type {
object.key("AttributeType").string(var_619.as_str());
}
if let Some(var_620) = &input.values {
let mut array_621 = object.key("Values").start_array();
for item_622 in var_620 {
{
array_621.value().string(item_622.as_str());
}
}
array_621.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::SerializationError> {
if let Some(var_623) = &input.recency {
let mut object_624 = object.key("Recency").start_object();
crate::json_ser::serialize_structure_crate_model_recency_dimension(
&mut object_624,
var_623,
)?;
object_624.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::SerializationError> {
if let Some(var_625) = &input.app_version {
let mut object_626 = object.key("AppVersion").start_object();
crate::json_ser::serialize_structure_crate_model_set_dimension(&mut object_626, var_625)?;
object_626.finish();
}
if let Some(var_627) = &input.channel {
let mut object_628 = object.key("Channel").start_object();
crate::json_ser::serialize_structure_crate_model_set_dimension(&mut object_628, var_627)?;
object_628.finish();
}
if let Some(var_629) = &input.device_type {
let mut object_630 = object.key("DeviceType").start_object();
crate::json_ser::serialize_structure_crate_model_set_dimension(&mut object_630, var_629)?;
object_630.finish();
}
if let Some(var_631) = &input.make {
let mut object_632 = object.key("Make").start_object();
crate::json_ser::serialize_structure_crate_model_set_dimension(&mut object_632, var_631)?;
object_632.finish();
}
if let Some(var_633) = &input.model {
let mut object_634 = object.key("Model").start_object();
crate::json_ser::serialize_structure_crate_model_set_dimension(&mut object_634, var_633)?;
object_634.finish();
}
if let Some(var_635) = &input.platform {
let mut object_636 = object.key("Platform").start_object();
crate::json_ser::serialize_structure_crate_model_set_dimension(&mut object_636, var_635)?;
object_636.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::SerializationError> {
if let Some(var_637) = &input.country {
let mut object_638 = object.key("Country").start_object();
crate::json_ser::serialize_structure_crate_model_set_dimension(&mut object_638, var_637)?;
object_638.finish();
}
if let Some(var_639) = &input.gps_point {
let mut object_640 = object.key("GPSPoint").start_object();
crate::json_ser::serialize_structure_crate_model_gps_point_dimension(
&mut object_640,
var_639,
)?;
object_640.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::SerializationError> {
if let Some(var_641) = &input.comparison_operator {
object.key("ComparisonOperator").string(var_641.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::SerializationError> {
if let Some(var_642) = &input.dimensions {
let mut array_643 = object.key("Dimensions").start_array();
for item_644 in var_642 {
{
let mut object_645 = array_643.value().start_object();
crate::json_ser::serialize_structure_crate_model_segment_dimensions(
&mut object_645,
item_644,
)?;
object_645.finish();
}
}
array_643.finish();
}
if let Some(var_646) = &input.source_segments {
let mut array_647 = object.key("SourceSegments").start_array();
for item_648 in var_646 {
{
let mut object_649 = array_647.value().start_object();
crate::json_ser::serialize_structure_crate_model_segment_reference(
&mut object_649,
item_648,
)?;
object_649.finish();
}
}
array_647.finish();
}
if let Some(var_650) = &input.source_type {
object.key("SourceType").string(var_650.as_str());
}
if let Some(var_651) = &input.r#type {
object.key("Type").string(var_651.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::SerializationError> {
if let Some(var_652) = &input.address {
object.key("Address").string(var_652.as_str());
}
if let Some(var_653) = &input.attributes {
let mut object_654 = object.key("Attributes").start_object();
for (key_655, value_656) in var_653 {
{
let mut array_657 = object_654.key(key_655).start_array();
for item_658 in value_656 {
{
array_657.value().string(item_658.as_str());
}
}
array_657.finish();
}
}
object_654.finish();
}
if let Some(var_659) = &input.channel_type {
object.key("ChannelType").string(var_659.as_str());
}
if let Some(var_660) = &input.demographic {
let mut object_661 = object.key("Demographic").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_demographic(
&mut object_661,
var_660,
)?;
object_661.finish();
}
if let Some(var_662) = &input.effective_date {
object.key("EffectiveDate").string(var_662.as_str());
}
if let Some(var_663) = &input.endpoint_status {
object.key("EndpointStatus").string(var_663.as_str());
}
if let Some(var_664) = &input.location {
let mut object_665 = object.key("Location").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_location(
&mut object_665,
var_664,
)?;
object_665.finish();
}
if let Some(var_666) = &input.metrics {
let mut object_667 = object.key("Metrics").start_object();
for (key_668, value_669) in var_666 {
{
object_667.key(key_668).number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*value_669).into()),
);
}
}
object_667.finish();
}
if let Some(var_670) = &input.opt_out {
object.key("OptOut").string(var_670.as_str());
}
if let Some(var_671) = &input.request_id {
object.key("RequestId").string(var_671.as_str());
}
if let Some(var_672) = &input.user {
let mut object_673 = object.key("User").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_user(&mut object_673, var_672)?;
object_673.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::SerializationError> {
if let Some(var_674) = &input.app_package_name {
object.key("AppPackageName").string(var_674.as_str());
}
if let Some(var_675) = &input.app_title {
object.key("AppTitle").string(var_675.as_str());
}
if let Some(var_676) = &input.app_version_code {
object.key("AppVersionCode").string(var_676.as_str());
}
if let Some(var_677) = &input.attributes {
let mut object_678 = object.key("Attributes").start_object();
for (key_679, value_680) in var_677 {
{
object_678.key(key_679).string(value_680.as_str());
}
}
object_678.finish();
}
if let Some(var_681) = &input.client_sdk_version {
object.key("ClientSdkVersion").string(var_681.as_str());
}
if let Some(var_682) = &input.event_type {
object.key("EventType").string(var_682.as_str());
}
if let Some(var_683) = &input.metrics {
let mut object_684 = object.key("Metrics").start_object();
for (key_685, value_686) in var_683 {
{
object_684.key(key_685).number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*value_686).into()),
);
}
}
object_684.finish();
}
if let Some(var_687) = &input.sdk_name {
object.key("SdkName").string(var_687.as_str());
}
if let Some(var_688) = &input.session {
let mut object_689 = object.key("Session").start_object();
crate::json_ser::serialize_structure_crate_model_session(&mut object_689, var_688)?;
object_689.finish();
}
if let Some(var_690) = &input.timestamp {
object.key("Timestamp").string(var_690.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::SerializationError> {
if let Some(var_691) = &input.action {
object.key("Action").string(var_691.as_str());
}
if let Some(var_692) = &input.body {
object.key("Body").string(var_692.as_str());
}
if let Some(var_693) = &input.consolidation_key {
object.key("ConsolidationKey").string(var_693.as_str());
}
if let Some(var_694) = &input.data {
let mut object_695 = object.key("Data").start_object();
for (key_696, value_697) in var_694 {
{
object_695.key(key_696).string(value_697.as_str());
}
}
object_695.finish();
}
if let Some(var_698) = &input.expires_after {
object.key("ExpiresAfter").string(var_698.as_str());
}
if let Some(var_699) = &input.icon_reference {
object.key("IconReference").string(var_699.as_str());
}
if let Some(var_700) = &input.image_icon_url {
object.key("ImageIconUrl").string(var_700.as_str());
}
if let Some(var_701) = &input.image_url {
object.key("ImageUrl").string(var_701.as_str());
}
if let Some(var_702) = &input.md5 {
object.key("MD5").string(var_702.as_str());
}
if let Some(var_703) = &input.raw_content {
object.key("RawContent").string(var_703.as_str());
}
if input.silent_push {
object.key("SilentPush").boolean(input.silent_push);
}
if let Some(var_704) = &input.small_image_icon_url {
object.key("SmallImageIconUrl").string(var_704.as_str());
}
if let Some(var_705) = &input.sound {
object.key("Sound").string(var_705.as_str());
}
if let Some(var_706) = &input.substitutions {
let mut object_707 = object.key("Substitutions").start_object();
for (key_708, value_709) in var_706 {
{
let mut array_710 = object_707.key(key_708).start_array();
for item_711 in value_709 {
{
array_710.value().string(item_711.as_str());
}
}
array_710.finish();
}
}
object_707.finish();
}
if let Some(var_712) = &input.title {
object.key("Title").string(var_712.as_str());
}
if let Some(var_713) = &input.url {
object.key("Url").string(var_713.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::SerializationError> {
if let Some(var_714) = &input.apns_push_type {
object.key("APNSPushType").string(var_714.as_str());
}
if let Some(var_715) = &input.action {
object.key("Action").string(var_715.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_716) = &input.body {
object.key("Body").string(var_716.as_str());
}
if let Some(var_717) = &input.category {
object.key("Category").string(var_717.as_str());
}
if let Some(var_718) = &input.collapse_id {
object.key("CollapseId").string(var_718.as_str());
}
if let Some(var_719) = &input.data {
let mut object_720 = object.key("Data").start_object();
for (key_721, value_722) in var_719 {
{
object_720.key(key_721).string(value_722.as_str());
}
}
object_720.finish();
}
if let Some(var_723) = &input.media_url {
object.key("MediaUrl").string(var_723.as_str());
}
if let Some(var_724) = &input.preferred_authentication_method {
object
.key("PreferredAuthenticationMethod")
.string(var_724.as_str());
}
if let Some(var_725) = &input.priority {
object.key("Priority").string(var_725.as_str());
}
if let Some(var_726) = &input.raw_content {
object.key("RawContent").string(var_726.as_str());
}
if input.silent_push {
object.key("SilentPush").boolean(input.silent_push);
}
if let Some(var_727) = &input.sound {
object.key("Sound").string(var_727.as_str());
}
if let Some(var_728) = &input.substitutions {
let mut object_729 = object.key("Substitutions").start_object();
for (key_730, value_731) in var_728 {
{
let mut array_732 = object_729.key(key_730).start_array();
for item_733 in value_731 {
{
array_732.value().string(item_733.as_str());
}
}
array_732.finish();
}
}
object_729.finish();
}
if let Some(var_734) = &input.thread_id {
object.key("ThreadId").string(var_734.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_735) = &input.title {
object.key("Title").string(var_735.as_str());
}
if let Some(var_736) = &input.url {
object.key("Url").string(var_736.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::SerializationError> {
if let Some(var_737) = &input.action {
object.key("Action").string(var_737.as_str());
}
if let Some(var_738) = &input.body {
object.key("Body").string(var_738.as_str());
}
if let Some(var_739) = &input.data {
let mut object_740 = object.key("Data").start_object();
for (key_741, value_742) in var_739 {
{
object_740.key(key_741).string(value_742.as_str());
}
}
object_740.finish();
}
if let Some(var_743) = &input.icon_reference {
object.key("IconReference").string(var_743.as_str());
}
if let Some(var_744) = &input.image_icon_url {
object.key("ImageIconUrl").string(var_744.as_str());
}
if let Some(var_745) = &input.image_url {
object.key("ImageUrl").string(var_745.as_str());
}
if let Some(var_746) = &input.raw_content {
object.key("RawContent").string(var_746.as_str());
}
if input.silent_push {
object.key("SilentPush").boolean(input.silent_push);
}
if let Some(var_747) = &input.small_image_icon_url {
object.key("SmallImageIconUrl").string(var_747.as_str());
}
if let Some(var_748) = &input.sound {
object.key("Sound").string(var_748.as_str());
}
if let Some(var_749) = &input.substitutions {
let mut object_750 = object.key("Substitutions").start_object();
for (key_751, value_752) in var_749 {
{
let mut array_753 = object_750.key(key_751).start_array();
for item_754 in value_752 {
{
array_753.value().string(item_754.as_str());
}
}
array_753.finish();
}
}
object_750.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_755) = &input.title {
object.key("Title").string(var_755.as_str());
}
if let Some(var_756) = &input.url {
object.key("Url").string(var_756.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::SerializationError> {
if let Some(var_757) = &input.body {
object.key("Body").string(var_757.as_str());
}
if let Some(var_758) = &input.substitutions {
let mut object_759 = object.key("Substitutions").start_object();
for (key_760, value_761) in var_758 {
{
let mut array_762 = object_759.key(key_760).start_array();
for item_763 in value_761 {
{
array_762.value().string(item_763.as_str());
}
}
array_762.finish();
}
}
object_759.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::SerializationError> {
if let Some(var_764) = &input.action {
object.key("Action").string(var_764.as_str());
}
if let Some(var_765) = &input.body {
object.key("Body").string(var_765.as_str());
}
if let Some(var_766) = &input.data {
let mut object_767 = object.key("Data").start_object();
for (key_768, value_769) in var_766 {
{
object_767.key(key_768).string(value_769.as_str());
}
}
object_767.finish();
}
if input.silent_push {
object.key("SilentPush").boolean(input.silent_push);
}
if let Some(var_770) = &input.substitutions {
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).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_email_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EmailMessage,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_778) = &input.body {
object.key("Body").string(var_778.as_str());
}
if let Some(var_779) = &input.feedback_forwarding_address {
object
.key("FeedbackForwardingAddress")
.string(var_779.as_str());
}
if let Some(var_780) = &input.from_address {
object.key("FromAddress").string(var_780.as_str());
}
if let Some(var_781) = &input.raw_email {
let mut object_782 = object.key("RawEmail").start_object();
crate::json_ser::serialize_structure_crate_model_raw_email(&mut object_782, var_781)?;
object_782.finish();
}
if let Some(var_783) = &input.reply_to_addresses {
let mut array_784 = object.key("ReplyToAddresses").start_array();
for item_785 in var_783 {
{
array_784.value().string(item_785.as_str());
}
}
array_784.finish();
}
if let Some(var_786) = &input.simple_email {
let mut object_787 = object.key("SimpleEmail").start_object();
crate::json_ser::serialize_structure_crate_model_simple_email(&mut object_787, var_786)?;
object_787.finish();
}
if let Some(var_788) = &input.substitutions {
let mut object_789 = object.key("Substitutions").start_object();
for (key_790, value_791) in var_788 {
{
let mut array_792 = object_789.key(key_790).start_array();
for item_793 in value_791 {
{
array_792.value().string(item_793.as_str());
}
}
array_792.finish();
}
}
object_789.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::SerializationError> {
if let Some(var_794) = &input.action {
object.key("Action").string(var_794.as_str());
}
if let Some(var_795) = &input.body {
object.key("Body").string(var_795.as_str());
}
if let Some(var_796) = &input.collapse_key {
object.key("CollapseKey").string(var_796.as_str());
}
if let Some(var_797) = &input.data {
let mut object_798 = object.key("Data").start_object();
for (key_799, value_800) in var_797 {
{
object_798.key(key_799).string(value_800.as_str());
}
}
object_798.finish();
}
if let Some(var_801) = &input.icon_reference {
object.key("IconReference").string(var_801.as_str());
}
if let Some(var_802) = &input.image_icon_url {
object.key("ImageIconUrl").string(var_802.as_str());
}
if let Some(var_803) = &input.image_url {
object.key("ImageUrl").string(var_803.as_str());
}
if let Some(var_804) = &input.priority {
object.key("Priority").string(var_804.as_str());
}
if let Some(var_805) = &input.raw_content {
object.key("RawContent").string(var_805.as_str());
}
if let Some(var_806) = &input.restricted_package_name {
object.key("RestrictedPackageName").string(var_806.as_str());
}
if input.silent_push {
object.key("SilentPush").boolean(input.silent_push);
}
if let Some(var_807) = &input.small_image_icon_url {
object.key("SmallImageIconUrl").string(var_807.as_str());
}
if let Some(var_808) = &input.sound {
object.key("Sound").string(var_808.as_str());
}
if let Some(var_809) = &input.substitutions {
let mut object_810 = object.key("Substitutions").start_object();
for (key_811, value_812) in var_809 {
{
let mut array_813 = object_810.key(key_811).start_array();
for item_814 in value_812 {
{
array_813.value().string(item_814.as_str());
}
}
array_813.finish();
}
}
object_810.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_815) = &input.title {
object.key("Title").string(var_815.as_str());
}
if let Some(var_816) = &input.url {
object.key("Url").string(var_816.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::SerializationError> {
if let Some(var_817) = &input.body {
object.key("Body").string(var_817.as_str());
}
if let Some(var_818) = &input.keyword {
object.key("Keyword").string(var_818.as_str());
}
if let Some(var_819) = &input.media_url {
object.key("MediaUrl").string(var_819.as_str());
}
if let Some(var_820) = &input.message_type {
object.key("MessageType").string(var_820.as_str());
}
if let Some(var_821) = &input.origination_number {
object.key("OriginationNumber").string(var_821.as_str());
}
if let Some(var_822) = &input.sender_id {
object.key("SenderId").string(var_822.as_str());
}
if let Some(var_823) = &input.substitutions {
let mut object_824 = object.key("Substitutions").start_object();
for (key_825, value_826) in var_823 {
{
let mut array_827 = object_824.key(key_825).start_array();
for item_828 in value_826 {
{
array_827.value().string(item_828.as_str());
}
}
array_827.finish();
}
}
object_824.finish();
}
if let Some(var_829) = &input.entity_id {
object.key("EntityId").string(var_829.as_str());
}
if let Some(var_830) = &input.template_id {
object.key("TemplateId").string(var_830.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::SerializationError> {
if let Some(var_831) = &input.body {
object.key("Body").string(var_831.as_str());
}
if let Some(var_832) = &input.language_code {
object.key("LanguageCode").string(var_832.as_str());
}
if let Some(var_833) = &input.origination_number {
object.key("OriginationNumber").string(var_833.as_str());
}
if let Some(var_834) = &input.substitutions {
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).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.voice_id {
object.key("VoiceId").string(var_840.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::SerializationError> {
if let Some(var_841) = &input.attributes {
let mut object_842 = object.key("Attributes").start_object();
for (key_843, value_844) in var_841 {
{
let mut object_845 = object_842.key(key_843).start_object();
crate::json_ser::serialize_structure_crate_model_attribute_dimension(
&mut object_845,
value_844,
)?;
object_845.finish();
}
}
object_842.finish();
}
if let Some(var_846) = &input.event_type {
let mut object_847 = object.key("EventType").start_object();
crate::json_ser::serialize_structure_crate_model_set_dimension(&mut object_847, var_846)?;
object_847.finish();
}
if let Some(var_848) = &input.metrics {
let mut object_849 = object.key("Metrics").start_object();
for (key_850, value_851) in var_848 {
{
let mut object_852 = object_849.key(key_850).start_object();
crate::json_ser::serialize_structure_crate_model_metric_dimension(
&mut object_852,
value_851,
)?;
object_852.finish();
}
}
object_849.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::SerializationError> {
if let Some(var_853) = &input.button_action {
object.key("ButtonAction").string(var_853.as_str());
}
if let Some(var_854) = &input.link {
object.key("Link").string(var_854.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::SerializationError> {
if let Some(var_855) = &input.background_color {
object.key("BackgroundColor").string(var_855.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_856) = &input.button_action {
object.key("ButtonAction").string(var_856.as_str());
}
if let Some(var_857) = &input.link {
object.key("Link").string(var_857.as_str());
}
if let Some(var_858) = &input.text {
object.key("Text").string(var_858.as_str());
}
if let Some(var_859) = &input.text_color {
object.key("TextColor").string(var_859.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::SerializationError> {
if let Some(var_860) = &input.data {
object.key("Data").string(var_860.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::SerializationError> {
if let Some(var_861) = &input.conditions {
let mut array_862 = object.key("Conditions").start_array();
for item_863 in var_861 {
{
let mut object_864 = array_862.value().start_object();
crate::json_ser::serialize_structure_crate_model_simple_condition(
&mut object_864,
item_863,
)?;
object_864.finish();
}
}
array_862.finish();
}
if let Some(var_865) = &input.operator {
object.key("Operator").string(var_865.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::SerializationError> {
if let Some(var_866) = &input.wait_for {
object.key("WaitFor").string(var_866.as_str());
}
if let Some(var_867) = &input.wait_until {
object.key("WaitUntil").string(var_867.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::SerializationError> {
if let Some(var_868) = &input.from_address {
object.key("FromAddress").string(var_868.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::SerializationError> {
if let Some(var_869) = &input.condition {
let mut object_870 = object.key("Condition").start_object();
crate::json_ser::serialize_structure_crate_model_simple_condition(
&mut object_870,
var_869,
)?;
object_870.finish();
}
if let Some(var_871) = &input.next_activity {
object.key("NextActivity").string(var_871.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::SerializationError> {
if let Some(var_872) = &input.time_to_live {
object.key("TimeToLive").string(var_872.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::SerializationError> {
if let Some(var_873) = &input.next_activity {
object.key("NextActivity").string(var_873.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::SerializationError> {
if let Some(var_874) = &input.message_type {
object.key("MessageType").string(var_874.as_str());
}
if let Some(var_875) = &input.origination_number {
object.key("OriginationNumber").string(var_875.as_str());
}
if let Some(var_876) = &input.sender_id {
object.key("SenderId").string(var_876.as_str());
}
if let Some(var_877) = &input.entity_id {
object.key("EntityId").string(var_877.as_str());
}
if let Some(var_878) = &input.template_id {
object.key("TemplateId").string(var_878.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::SerializationError> {
if let Some(var_879) = &input.dimensions {
let mut object_880 = object.key("Dimensions").start_object();
crate::json_ser::serialize_structure_crate_model_event_dimensions(
&mut object_880,
var_879,
)?;
object_880.finish();
}
if let Some(var_881) = &input.filter_type {
object.key("FilterType").string(var_881.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::SerializationError> {
if let Some(var_882) = &input.duration {
object.key("Duration").string(var_882.as_str());
}
if let Some(var_883) = &input.recency_type {
object.key("RecencyType").string(var_883.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::SerializationError> {
if let Some(var_884) = &input.dimension_type {
object.key("DimensionType").string(var_884.as_str());
}
if let Some(var_885) = &input.values {
let mut array_886 = object.key("Values").start_array();
for item_887 in var_885 {
{
array_886.value().string(item_887.as_str());
}
}
array_886.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::SerializationError> {
if let Some(var_888) = &input.coordinates {
let mut object_889 = object.key("Coordinates").start_object();
crate::json_ser::serialize_structure_crate_model_gps_coordinates(&mut object_889, var_888)?;
object_889.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::SerializationError> {
if let Some(var_890) = &input.id {
object.key("Id").string(var_890.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::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_891) = &input.id {
object.key("Id").string(var_891.as_str());
}
if let Some(var_892) = &input.start_timestamp {
object.key("StartTimestamp").string(var_892.as_str());
}
if let Some(var_893) = &input.stop_timestamp {
object.key("StopTimestamp").string(var_893.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::SerializationError> {
if let Some(var_894) = &input.data {
object
.key("Data")
.string_unchecked(&aws_smithy_types::base64::encode(var_894));
}
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::SerializationError> {
if let Some(var_895) = &input.html_part {
let mut object_896 = object.key("HtmlPart").start_object();
crate::json_ser::serialize_structure_crate_model_simple_email_part(
&mut object_896,
var_895,
)?;
object_896.finish();
}
if let Some(var_897) = &input.subject {
let mut object_898 = object.key("Subject").start_object();
crate::json_ser::serialize_structure_crate_model_simple_email_part(
&mut object_898,
var_897,
)?;
object_898.finish();
}
if let Some(var_899) = &input.text_part {
let mut object_900 = object.key("TextPart").start_object();
crate::json_ser::serialize_structure_crate_model_simple_email_part(
&mut object_900,
var_899,
)?;
object_900.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::SerializationError> {
if let Some(var_901) = &input.event_condition {
let mut object_902 = object.key("EventCondition").start_object();
crate::json_ser::serialize_structure_crate_model_event_condition(&mut object_902, var_901)?;
object_902.finish();
}
if let Some(var_903) = &input.segment_condition {
let mut object_904 = object.key("SegmentCondition").start_object();
crate::json_ser::serialize_structure_crate_model_segment_condition(
&mut object_904,
var_903,
)?;
object_904.finish();
}
if let Some(var_905) = &input.segment_dimensions {
let mut object_906 = object.key("segmentDimensions").start_object();
crate::json_ser::serialize_structure_crate_model_segment_dimensions(
&mut object_906,
var_905,
)?;
object_906.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::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::SerializationError> {
if let Some(var_907) = &input.charset {
object.key("Charset").string(var_907.as_str());
}
if let Some(var_908) = &input.data {
object.key("Data").string(var_908.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::SerializationError> {
if let Some(var_909) = &input.dimensions {
let mut object_910 = object.key("Dimensions").start_object();
crate::json_ser::serialize_structure_crate_model_event_dimensions(
&mut object_910,
var_909,
)?;
object_910.finish();
}
if let Some(var_911) = &input.message_activity {
object.key("MessageActivity").string(var_911.as_str());
}
Ok(())
}