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);
}
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);
}
}
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);
}
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);
}
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);
}
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);
}
}
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);
}
if let Some(var_30) = &input.treatment_name {
object.key("TreatmentName").string(var_30);
}
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);
}
if let Some(var_32) = &input.html_part {
object.key("HtmlPart").string(var_32);
}
if let Some(var_33) = &input.recommender_id {
object.key("RecommenderId").string(var_33);
}
if let Some(var_34) = &input.subject {
object.key("Subject").string(var_34);
}
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);
}
}
object_36.finish();
}
if let Some(var_39) = &input.template_description {
object.key("TemplateDescription").string(var_39);
}
if let Some(var_40) = &input.text_part {
object.key("TextPart").string(var_40);
}
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);
}
if let Some(var_42) = &input.s3_url_prefix {
object.key("S3UrlPrefix").string(var_42);
}
if let Some(var_43) = &input.segment_id {
object.key("SegmentId").string(var_43);
}
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);
}
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);
}
if let Some(var_47) = &input.s3_url {
object.key("S3Url").string(var_47);
}
if let Some(var_48) = &input.segment_id {
object.key("SegmentId").string(var_48);
}
if let Some(var_49) = &input.segment_name {
object.key("SegmentName").string(var_49);
}
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);
}
}
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);
}
}
object_60.finish();
}
if let Some(var_63) = &input.template_description {
object.key("TemplateDescription").string(var_63);
}
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);
}
if let Some(var_70) = &input.last_modified_date {
object.key("LastModifiedDate").string(var_70);
}
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);
}
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);
}
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);
}
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);
}
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_83) = &input.adm {
let mut object_84 = object.key("ADM").start_object();
crate::json_ser::serialize_structure_crate_model_android_push_notification_template(
&mut object_84,
var_83,
)?;
object_84.finish();
}
if let Some(var_85) = &input.apns {
let mut object_86 = object.key("APNS").start_object();
crate::json_ser::serialize_structure_crate_model_apns_push_notification_template(
&mut object_86,
var_85,
)?;
object_86.finish();
}
if let Some(var_87) = &input.baidu {
let mut object_88 = object.key("Baidu").start_object();
crate::json_ser::serialize_structure_crate_model_android_push_notification_template(
&mut object_88,
var_87,
)?;
object_88.finish();
}
if let Some(var_89) = &input.default_value {
let mut object_90 = object.key("Default").start_object();
crate::json_ser::serialize_structure_crate_model_default_push_notification_template(
&mut object_90,
var_89,
)?;
object_90.finish();
}
if let Some(var_91) = &input.default_substitutions {
object.key("DefaultSubstitutions").string(var_91);
}
if let Some(var_92) = &input.gcm {
let mut object_93 = object.key("GCM").start_object();
crate::json_ser::serialize_structure_crate_model_android_push_notification_template(
&mut object_93,
var_92,
)?;
object_93.finish();
}
if let Some(var_94) = &input.recommender_id {
object.key("RecommenderId").string(var_94);
}
if let Some(var_95) = &input.tags {
let mut object_96 = object.key("tags").start_object();
for (key_97, value_98) in var_95 {
{
object_96.key(key_97).string(value_98);
}
}
object_96.finish();
}
if let Some(var_99) = &input.template_description {
object.key("TemplateDescription").string(var_99);
}
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_100) = &input.attributes {
let mut object_101 = object.key("Attributes").start_object();
for (key_102, value_103) in var_100 {
{
object_101.key(key_102).string(value_103);
}
}
object_101.finish();
}
if let Some(var_104) = &input.description {
object.key("Description").string(var_104);
}
if let Some(var_105) = &input.name {
object.key("Name").string(var_105);
}
if let Some(var_106) = &input.recommendation_provider_id_type {
object.key("RecommendationProviderIdType").string(var_106);
}
if let Some(var_107) = &input.recommendation_provider_role_arn {
object.key("RecommendationProviderRoleArn").string(var_107);
}
if let Some(var_108) = &input.recommendation_provider_uri {
object.key("RecommendationProviderUri").string(var_108);
}
if let Some(var_109) = &input.recommendation_transformer_uri {
object.key("RecommendationTransformerUri").string(var_109);
}
if let Some(var_110) = &input.recommendations_display_name {
object.key("RecommendationsDisplayName").string(var_110);
}
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_111) = &input.dimensions {
let mut object_112 = object.key("Dimensions").start_object();
crate::json_ser::serialize_structure_crate_model_segment_dimensions(
&mut object_112,
var_111,
)?;
object_112.finish();
}
if let Some(var_113) = &input.name {
object.key("Name").string(var_113);
}
if let Some(var_114) = &input.segment_groups {
let mut object_115 = object.key("SegmentGroups").start_object();
crate::json_ser::serialize_structure_crate_model_segment_group_list(
&mut object_115,
var_114,
)?;
object_115.finish();
}
if let Some(var_116) = &input.tags {
let mut object_117 = object.key("tags").start_object();
for (key_118, value_119) in var_116 {
{
object_117.key(key_118).string(value_119);
}
}
object_117.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_120) = &input.body {
object.key("Body").string(var_120);
}
if let Some(var_121) = &input.default_substitutions {
object.key("DefaultSubstitutions").string(var_121);
}
if let Some(var_122) = &input.recommender_id {
object.key("RecommenderId").string(var_122);
}
if let Some(var_123) = &input.tags {
let mut object_124 = object.key("tags").start_object();
for (key_125, value_126) in var_123 {
{
object_124.key(key_125).string(value_126);
}
}
object_124.finish();
}
if let Some(var_127) = &input.template_description {
object.key("TemplateDescription").string(var_127);
}
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_128) = &input.body {
object.key("Body").string(var_128);
}
if let Some(var_129) = &input.default_substitutions {
object.key("DefaultSubstitutions").string(var_129);
}
if let Some(var_130) = &input.language_code {
object.key("LanguageCode").string(var_130);
}
if let Some(var_131) = &input.tags {
let mut object_132 = object.key("tags").start_object();
for (key_133, value_134) in var_131 {
{
object_132.key(key_133).string(value_134);
}
}
object_132.finish();
}
if let Some(var_135) = &input.template_description {
object.key("TemplateDescription").string(var_135);
}
if let Some(var_136) = &input.voice_id {
object.key("VoiceId").string(var_136);
}
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_137) = &input.iso_country_code {
object.key("IsoCountryCode").string(var_137);
}
if let Some(var_138) = &input.phone_number {
object.key("PhoneNumber").string(var_138);
}
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_139) = &input.batch_item {
let mut object_140 = object.key("BatchItem").start_object();
for (key_141, value_142) in var_139 {
{
let mut object_143 = object_140.key(key_141).start_object();
crate::json_ser::serialize_structure_crate_model_events_batch(
&mut object_143,
value_142,
)?;
object_143.finish();
}
}
object_140.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_144) = &input.destination_stream_arn {
object.key("DestinationStreamArn").string(var_144);
}
if let Some(var_145) = &input.role_arn {
object.key("RoleArn").string(var_145);
}
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_146) = &input.blacklist {
let mut array_147 = object.key("Blacklist").start_array();
for item_148 in var_146 {
{
array_147.value().string(item_148);
}
}
array_147.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_149) = &input.addresses {
let mut object_150 = object.key("Addresses").start_object();
for (key_151, value_152) in var_149 {
{
let mut object_153 = object_150.key(key_151).start_object();
crate::json_ser::serialize_structure_crate_model_address_configuration(
&mut object_153,
value_152,
)?;
object_153.finish();
}
}
object_150.finish();
}
if let Some(var_154) = &input.context {
let mut object_155 = object.key("Context").start_object();
for (key_156, value_157) in var_154 {
{
object_155.key(key_156).string(value_157);
}
}
object_155.finish();
}
if let Some(var_158) = &input.endpoints {
let mut object_159 = object.key("Endpoints").start_object();
for (key_160, value_161) in var_158 {
{
let mut object_162 = object_159.key(key_160).start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_send_configuration(
&mut object_162,
value_161,
)?;
object_162.finish();
}
}
object_159.finish();
}
if let Some(var_163) = &input.message_configuration {
let mut object_164 = object.key("MessageConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_direct_message_configuration(
&mut object_164,
var_163,
)?;
object_164.finish();
}
if let Some(var_165) = &input.template_configuration {
let mut object_166 = object.key("TemplateConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_template_configuration(
&mut object_166,
var_165,
)?;
object_166.finish();
}
if let Some(var_167) = &input.trace_id {
object.key("TraceId").string(var_167);
}
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_168) = &input.brand_name {
object.key("BrandName").string(var_168);
}
if let Some(var_169) = &input.channel {
object.key("Channel").string(var_169);
}
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_170) = &input.destination_identity {
object.key("DestinationIdentity").string(var_170);
}
if let Some(var_171) = &input.entity_id {
object.key("EntityId").string(var_171);
}
if let Some(var_172) = &input.language {
object.key("Language").string(var_172);
}
if let Some(var_173) = &input.origination_identity {
object.key("OriginationIdentity").string(var_173);
}
if let Some(var_174) = &input.reference_id {
object.key("ReferenceId").string(var_174);
}
if let Some(var_175) = &input.template_id {
object.key("TemplateId").string(var_175);
}
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_176) = &input.context {
let mut object_177 = object.key("Context").start_object();
for (key_178, value_179) in var_176 {
{
object_177.key(key_178).string(value_179);
}
}
object_177.finish();
}
if let Some(var_180) = &input.message_configuration {
let mut object_181 = object.key("MessageConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_direct_message_configuration(
&mut object_181,
var_180,
)?;
object_181.finish();
}
if let Some(var_182) = &input.template_configuration {
let mut object_183 = object.key("TemplateConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_template_configuration(
&mut object_183,
var_182,
)?;
object_183.finish();
}
if let Some(var_184) = &input.trace_id {
object.key("TraceId").string(var_184);
}
if let Some(var_185) = &input.users {
let mut object_186 = object.key("Users").start_object();
for (key_187, value_188) in var_185 {
{
let mut object_189 = object_186.key(key_187).start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_send_configuration(
&mut object_189,
value_188,
)?;
object_189.finish();
}
}
object_186.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_190) = &input.tags {
let mut object_191 = object.key("tags").start_object();
for (key_192, value_193) in var_190 {
{
object_191.key(key_192).string(value_193);
}
}
object_191.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_194) = &input.client_id {
object.key("ClientId").string(var_194);
}
if let Some(var_195) = &input.client_secret {
object.key("ClientSecret").string(var_195);
}
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_196) = &input.bundle_id {
object.key("BundleId").string(var_196);
}
if let Some(var_197) = &input.certificate {
object.key("Certificate").string(var_197);
}
if let Some(var_198) = &input.default_authentication_method {
object.key("DefaultAuthenticationMethod").string(var_198);
}
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_199) = &input.private_key {
object.key("PrivateKey").string(var_199);
}
if let Some(var_200) = &input.team_id {
object.key("TeamId").string(var_200);
}
if let Some(var_201) = &input.token_key {
object.key("TokenKey").string(var_201);
}
if let Some(var_202) = &input.token_key_id {
object.key("TokenKeyId").string(var_202);
}
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_203) = &input.bundle_id {
object.key("BundleId").string(var_203);
}
if let Some(var_204) = &input.certificate {
object.key("Certificate").string(var_204);
}
if let Some(var_205) = &input.default_authentication_method {
object.key("DefaultAuthenticationMethod").string(var_205);
}
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_206) = &input.private_key {
object.key("PrivateKey").string(var_206);
}
if let Some(var_207) = &input.team_id {
object.key("TeamId").string(var_207);
}
if let Some(var_208) = &input.token_key {
object.key("TokenKey").string(var_208);
}
if let Some(var_209) = &input.token_key_id {
object.key("TokenKeyId").string(var_209);
}
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_210) = &input.bundle_id {
object.key("BundleId").string(var_210);
}
if let Some(var_211) = &input.certificate {
object.key("Certificate").string(var_211);
}
if let Some(var_212) = &input.default_authentication_method {
object.key("DefaultAuthenticationMethod").string(var_212);
}
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_213) = &input.private_key {
object.key("PrivateKey").string(var_213);
}
if let Some(var_214) = &input.team_id {
object.key("TeamId").string(var_214);
}
if let Some(var_215) = &input.token_key {
object.key("TokenKey").string(var_215);
}
if let Some(var_216) = &input.token_key_id {
object.key("TokenKeyId").string(var_216);
}
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_217) = &input.bundle_id {
object.key("BundleId").string(var_217);
}
if let Some(var_218) = &input.certificate {
object.key("Certificate").string(var_218);
}
if let Some(var_219) = &input.default_authentication_method {
object.key("DefaultAuthenticationMethod").string(var_219);
}
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_220) = &input.private_key {
object.key("PrivateKey").string(var_220);
}
if let Some(var_221) = &input.team_id {
object.key("TeamId").string(var_221);
}
if let Some(var_222) = &input.token_key {
object.key("TokenKey").string(var_222);
}
if let Some(var_223) = &input.token_key_id {
object.key("TokenKeyId").string(var_223);
}
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_224) = &input.campaign_hook {
let mut object_225 = object.key("CampaignHook").start_object();
crate::json_ser::serialize_structure_crate_model_campaign_hook(&mut object_225, var_224)?;
object_225.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_226) = &input.limits {
let mut object_227 = object.key("Limits").start_object();
crate::json_ser::serialize_structure_crate_model_campaign_limits(&mut object_227, var_226)?;
object_227.finish();
}
if let Some(var_228) = &input.quiet_time {
let mut object_229 = object.key("QuietTime").start_object();
crate::json_ser::serialize_structure_crate_model_quiet_time(&mut object_229, var_228)?;
object_229.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_230) = &input.api_key {
object.key("ApiKey").string(var_230);
}
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_231) = &input.secret_key {
object.key("SecretKey").string(var_231);
}
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_232) = &input.configuration_set {
object.key("ConfigurationSet").string(var_232);
}
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_233) = &input.from_address {
object.key("FromAddress").string(var_233);
}
if let Some(var_234) = &input.identity {
object.key("Identity").string(var_234);
}
if let Some(var_235) = &input.role_arn {
object.key("RoleArn").string(var_235);
}
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_236) = &input.address {
object.key("Address").string(var_236);
}
if let Some(var_237) = &input.attributes {
let mut object_238 = object.key("Attributes").start_object();
for (key_239, value_240) in var_237 {
{
let mut array_241 = object_238.key(key_239).start_array();
for item_242 in value_240 {
{
array_241.value().string(item_242);
}
}
array_241.finish();
}
}
object_238.finish();
}
if let Some(var_243) = &input.channel_type {
object.key("ChannelType").string(var_243.as_str());
}
if let Some(var_244) = &input.demographic {
let mut object_245 = object.key("Demographic").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_demographic(
&mut object_245,
var_244,
)?;
object_245.finish();
}
if let Some(var_246) = &input.effective_date {
object.key("EffectiveDate").string(var_246);
}
if let Some(var_247) = &input.endpoint_status {
object.key("EndpointStatus").string(var_247);
}
if let Some(var_248) = &input.location {
let mut object_249 = object.key("Location").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_location(
&mut object_249,
var_248,
)?;
object_249.finish();
}
if let Some(var_250) = &input.metrics {
let mut object_251 = object.key("Metrics").start_object();
for (key_252, value_253) in var_250 {
{
object_251.key(key_252).number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*value_253).into()),
);
}
}
object_251.finish();
}
if let Some(var_254) = &input.opt_out {
object.key("OptOut").string(var_254);
}
if let Some(var_255) = &input.request_id {
object.key("RequestId").string(var_255);
}
if let Some(var_256) = &input.user {
let mut object_257 = object.key("User").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_user(&mut object_257, var_256)?;
object_257.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_258) = &input.item {
let mut array_259 = object.key("Item").start_array();
for item_260 in var_258 {
{
let mut object_261 = array_259.value().start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_batch_item(
&mut object_261,
item_260,
)?;
object_261.finish();
}
}
array_259.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_262) = &input.api_key {
object.key("ApiKey").string(var_262);
}
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_263) = &input.state {
object.key("State").string(var_263.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_264) = &input.attributes {
let mut object_265 = object.key("Attributes").start_object();
for (key_266, value_267) in var_264 {
{
object_265.key(key_266).string(value_267);
}
}
object_265.finish();
}
if let Some(var_268) = &input.description {
object.key("Description").string(var_268);
}
if let Some(var_269) = &input.name {
object.key("Name").string(var_269);
}
if let Some(var_270) = &input.recommendation_provider_id_type {
object.key("RecommendationProviderIdType").string(var_270);
}
if let Some(var_271) = &input.recommendation_provider_role_arn {
object.key("RecommendationProviderRoleArn").string(var_271);
}
if let Some(var_272) = &input.recommendation_provider_uri {
object.key("RecommendationProviderUri").string(var_272);
}
if let Some(var_273) = &input.recommendation_transformer_uri {
object.key("RecommendationTransformerUri").string(var_273);
}
if let Some(var_274) = &input.recommendations_display_name {
object.key("RecommendationsDisplayName").string(var_274);
}
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_275) = &input.sender_id {
object.key("SenderId").string(var_275);
}
if let Some(var_276) = &input.short_code {
object.key("ShortCode").string(var_276);
}
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_277) = &input.version {
object.key("Version").string(var_277);
}
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_278) = &input.destination_identity {
object.key("DestinationIdentity").string(var_278);
}
if let Some(var_279) = &input.otp {
object.key("Otp").string(var_279);
}
if let Some(var_280) = &input.reference_id {
object.key("ReferenceId").string(var_280);
}
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_281) = &input.custom_delivery_configuration {
let mut object_282 = object.key("CustomDeliveryConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_custom_delivery_configuration(
&mut object_282,
var_281,
)?;
object_282.finish();
}
if let Some(var_283) = &input.message_configuration {
let mut object_284 = object.key("MessageConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_message_configuration(
&mut object_284,
var_283,
)?;
object_284.finish();
}
if let Some(var_285) = &input.schedule {
let mut object_286 = object.key("Schedule").start_object();
crate::json_ser::serialize_structure_crate_model_schedule(&mut object_286, var_285)?;
object_286.finish();
}
{
object.key("SizePercent").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.size_percent).into()),
);
}
if let Some(var_287) = &input.template_configuration {
let mut object_288 = object.key("TemplateConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_template_configuration(
&mut object_288,
var_287,
)?;
object_288.finish();
}
if let Some(var_289) = &input.treatment_description {
object.key("TreatmentDescription").string(var_289);
}
if let Some(var_290) = &input.treatment_name {
object.key("TreatmentName").string(var_290);
}
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_291) = &input.delivery_uri {
object.key("DeliveryUri").string(var_291);
}
if let Some(var_292) = &input.endpoint_types {
let mut array_293 = object.key("EndpointTypes").start_array();
for item_294 in var_292 {
{
array_293.value().string(item_294.as_str());
}
}
array_293.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_295) = &input.lambda_function_name {
object.key("LambdaFunctionName").string(var_295);
}
if let Some(var_296) = &input.mode {
object.key("Mode").string(var_296.as_str());
}
if let Some(var_297) = &input.web_url {
object.key("WebUrl").string(var_297);
}
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_298) = &input.adm_message {
let mut object_299 = object.key("ADMMessage").start_object();
crate::json_ser::serialize_structure_crate_model_message(&mut object_299, var_298)?;
object_299.finish();
}
if let Some(var_300) = &input.apns_message {
let mut object_301 = object.key("APNSMessage").start_object();
crate::json_ser::serialize_structure_crate_model_message(&mut object_301, var_300)?;
object_301.finish();
}
if let Some(var_302) = &input.baidu_message {
let mut object_303 = object.key("BaiduMessage").start_object();
crate::json_ser::serialize_structure_crate_model_message(&mut object_303, var_302)?;
object_303.finish();
}
if let Some(var_304) = &input.custom_message {
let mut object_305 = object.key("CustomMessage").start_object();
crate::json_ser::serialize_structure_crate_model_campaign_custom_message(
&mut object_305,
var_304,
)?;
object_305.finish();
}
if let Some(var_306) = &input.default_message {
let mut object_307 = object.key("DefaultMessage").start_object();
crate::json_ser::serialize_structure_crate_model_message(&mut object_307, var_306)?;
object_307.finish();
}
if let Some(var_308) = &input.email_message {
let mut object_309 = object.key("EmailMessage").start_object();
crate::json_ser::serialize_structure_crate_model_campaign_email_message(
&mut object_309,
var_308,
)?;
object_309.finish();
}
if let Some(var_310) = &input.gcm_message {
let mut object_311 = object.key("GCMMessage").start_object();
crate::json_ser::serialize_structure_crate_model_message(&mut object_311, var_310)?;
object_311.finish();
}
if let Some(var_312) = &input.sms_message {
let mut object_313 = object.key("SMSMessage").start_object();
crate::json_ser::serialize_structure_crate_model_campaign_sms_message(
&mut object_313,
var_312,
)?;
object_313.finish();
}
if let Some(var_314) = &input.in_app_message {
let mut object_315 = object.key("InAppMessage").start_object();
crate::json_ser::serialize_structure_crate_model_campaign_in_app_message(
&mut object_315,
var_314,
)?;
object_315.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_316) = &input.end_time {
object.key("EndTime").string(var_316);
}
if let Some(var_317) = &input.event_filter {
let mut object_318 = object.key("EventFilter").start_object();
crate::json_ser::serialize_structure_crate_model_campaign_event_filter(
&mut object_318,
var_317,
)?;
object_318.finish();
}
if let Some(var_319) = &input.frequency {
object.key("Frequency").string(var_319.as_str());
}
if input.is_local_time {
object.key("IsLocalTime").boolean(input.is_local_time);
}
if let Some(var_320) = &input.quiet_time {
let mut object_321 = object.key("QuietTime").start_object();
crate::json_ser::serialize_structure_crate_model_quiet_time(&mut object_321, var_320)?;
object_321.finish();
}
if let Some(var_322) = &input.start_time {
object.key("StartTime").string(var_322);
}
if let Some(var_323) = &input.timezone {
object.key("Timezone").string(var_323);
}
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_324) = &input.email_template {
let mut object_325 = object.key("EmailTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_template(&mut object_325, var_324)?;
object_325.finish();
}
if let Some(var_326) = &input.push_template {
let mut object_327 = object.key("PushTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_template(&mut object_327, var_326)?;
object_327.finish();
}
if let Some(var_328) = &input.sms_template {
let mut object_329 = object.key("SMSTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_template(&mut object_329, var_328)?;
object_329.finish();
}
if let Some(var_330) = &input.voice_template {
let mut object_331 = object.key("VoiceTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_template(&mut object_331, var_330)?;
object_331.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_332) = &input.background_color {
object.key("BackgroundColor").string(var_332);
}
if let Some(var_333) = &input.body_config {
let mut object_334 = object.key("BodyConfig").start_object();
crate::json_ser::serialize_structure_crate_model_in_app_message_body_config(
&mut object_334,
var_333,
)?;
object_334.finish();
}
if let Some(var_335) = &input.header_config {
let mut object_336 = object.key("HeaderConfig").start_object();
crate::json_ser::serialize_structure_crate_model_in_app_message_header_config(
&mut object_336,
var_335,
)?;
object_336.finish();
}
if let Some(var_337) = &input.image_url {
object.key("ImageUrl").string(var_337);
}
if let Some(var_338) = &input.primary_btn {
let mut object_339 = object.key("PrimaryBtn").start_object();
crate::json_ser::serialize_structure_crate_model_in_app_message_button(
&mut object_339,
var_338,
)?;
object_339.finish();
}
if let Some(var_340) = &input.secondary_btn {
let mut object_341 = object.key("SecondaryBtn").start_object();
crate::json_ser::serialize_structure_crate_model_in_app_message_button(
&mut object_341,
var_340,
)?;
object_341.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_342) = &input.custom {
let mut object_343 = object.key("CUSTOM").start_object();
crate::json_ser::serialize_structure_crate_model_custom_message_activity(
&mut object_343,
var_342,
)?;
object_343.finish();
}
if let Some(var_344) = &input.conditional_split {
let mut object_345 = object.key("ConditionalSplit").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_split_activity(
&mut object_345,
var_344,
)?;
object_345.finish();
}
if let Some(var_346) = &input.description {
object.key("Description").string(var_346);
}
if let Some(var_347) = &input.email {
let mut object_348 = object.key("EMAIL").start_object();
crate::json_ser::serialize_structure_crate_model_email_message_activity(
&mut object_348,
var_347,
)?;
object_348.finish();
}
if let Some(var_349) = &input.holdout {
let mut object_350 = object.key("Holdout").start_object();
crate::json_ser::serialize_structure_crate_model_holdout_activity(
&mut object_350,
var_349,
)?;
object_350.finish();
}
if let Some(var_351) = &input.multi_condition {
let mut object_352 = object.key("MultiCondition").start_object();
crate::json_ser::serialize_structure_crate_model_multi_conditional_split_activity(
&mut object_352,
var_351,
)?;
object_352.finish();
}
if let Some(var_353) = &input.push {
let mut object_354 = object.key("PUSH").start_object();
crate::json_ser::serialize_structure_crate_model_push_message_activity(
&mut object_354,
var_353,
)?;
object_354.finish();
}
if let Some(var_355) = &input.random_split {
let mut object_356 = object.key("RandomSplit").start_object();
crate::json_ser::serialize_structure_crate_model_random_split_activity(
&mut object_356,
var_355,
)?;
object_356.finish();
}
if let Some(var_357) = &input.sms {
let mut object_358 = object.key("SMS").start_object();
crate::json_ser::serialize_structure_crate_model_sms_message_activity(
&mut object_358,
var_357,
)?;
object_358.finish();
}
if let Some(var_359) = &input.wait {
let mut object_360 = object.key("Wait").start_object();
crate::json_ser::serialize_structure_crate_model_wait_activity(&mut object_360, var_359)?;
object_360.finish();
}
if let Some(var_361) = &input.contact_center {
let mut object_362 = object.key("ContactCenter").start_object();
crate::json_ser::serialize_structure_crate_model_contact_center_activity(
&mut object_362,
var_361,
)?;
object_362.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_363) = &input.endpoint_reentry_interval {
object.key("EndpointReentryInterval").string(var_363);
}
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_364) = &input.end {
object.key("End").string(var_364);
}
if let Some(var_365) = &input.start {
object.key("Start").string(var_365);
}
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_366) = &input.end_time {
object
.key("EndTime")
.date_time(var_366, aws_smithy_types::date_time::Format::DateTime)?;
}
if let Some(var_367) = &input.start_time {
object
.key("StartTime")
.date_time(var_367, aws_smithy_types::date_time::Format::DateTime)?;
}
if let Some(var_368) = &input.timezone {
object.key("Timezone").string(var_368);
}
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_369) = &input.description {
object.key("Description").string(var_369);
}
if let Some(var_370) = &input.event_start_condition {
let mut object_371 = object.key("EventStartCondition").start_object();
crate::json_ser::serialize_structure_crate_model_event_start_condition(
&mut object_371,
var_370,
)?;
object_371.finish();
}
if let Some(var_372) = &input.segment_start_condition {
let mut object_373 = object.key("SegmentStartCondition").start_object();
crate::json_ser::serialize_structure_crate_model_segment_condition(
&mut object_373,
var_372,
)?;
object_373.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_android_push_notification_template(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AndroidPushNotificationTemplate,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_374) = &input.action {
object.key("Action").string(var_374.as_str());
}
if let Some(var_375) = &input.body {
object.key("Body").string(var_375);
}
if let Some(var_376) = &input.image_icon_url {
object.key("ImageIconUrl").string(var_376);
}
if let Some(var_377) = &input.image_url {
object.key("ImageUrl").string(var_377);
}
if let Some(var_378) = &input.raw_content {
object.key("RawContent").string(var_378);
}
if let Some(var_379) = &input.small_image_icon_url {
object.key("SmallImageIconUrl").string(var_379);
}
if let Some(var_380) = &input.sound {
object.key("Sound").string(var_380);
}
if let Some(var_381) = &input.title {
object.key("Title").string(var_381);
}
if let Some(var_382) = &input.url {
object.key("Url").string(var_382);
}
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_383) = &input.action {
object.key("Action").string(var_383.as_str());
}
if let Some(var_384) = &input.body {
object.key("Body").string(var_384);
}
if let Some(var_385) = &input.media_url {
object.key("MediaUrl").string(var_385);
}
if let Some(var_386) = &input.raw_content {
object.key("RawContent").string(var_386);
}
if let Some(var_387) = &input.sound {
object.key("Sound").string(var_387);
}
if let Some(var_388) = &input.title {
object.key("Title").string(var_388);
}
if let Some(var_389) = &input.url {
object.key("Url").string(var_389);
}
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_390) = &input.action {
object.key("Action").string(var_390.as_str());
}
if let Some(var_391) = &input.body {
object.key("Body").string(var_391);
}
if let Some(var_392) = &input.sound {
object.key("Sound").string(var_392);
}
if let Some(var_393) = &input.title {
object.key("Title").string(var_393);
}
if let Some(var_394) = &input.url {
object.key("Url").string(var_394);
}
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_395) = &input.attributes {
let mut object_396 = object.key("Attributes").start_object();
for (key_397, value_398) in var_395 {
{
let mut object_399 = object_396.key(key_397).start_object();
crate::json_ser::serialize_structure_crate_model_attribute_dimension(
&mut object_399,
value_398,
)?;
object_399.finish();
}
}
object_396.finish();
}
if let Some(var_400) = &input.behavior {
let mut object_401 = object.key("Behavior").start_object();
crate::json_ser::serialize_structure_crate_model_segment_behaviors(
&mut object_401,
var_400,
)?;
object_401.finish();
}
if let Some(var_402) = &input.demographic {
let mut object_403 = object.key("Demographic").start_object();
crate::json_ser::serialize_structure_crate_model_segment_demographics(
&mut object_403,
var_402,
)?;
object_403.finish();
}
if let Some(var_404) = &input.location {
let mut object_405 = object.key("Location").start_object();
crate::json_ser::serialize_structure_crate_model_segment_location(
&mut object_405,
var_404,
)?;
object_405.finish();
}
if let Some(var_406) = &input.metrics {
let mut object_407 = object.key("Metrics").start_object();
for (key_408, value_409) in var_406 {
{
let mut object_410 = object_407.key(key_408).start_object();
crate::json_ser::serialize_structure_crate_model_metric_dimension(
&mut object_410,
value_409,
)?;
object_410.finish();
}
}
object_407.finish();
}
if let Some(var_411) = &input.user_attributes {
let mut object_412 = object.key("UserAttributes").start_object();
for (key_413, value_414) in var_411 {
{
let mut object_415 = object_412.key(key_413).start_object();
crate::json_ser::serialize_structure_crate_model_attribute_dimension(
&mut object_415,
value_414,
)?;
object_415.finish();
}
}
object_412.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_416) = &input.groups {
let mut array_417 = object.key("Groups").start_array();
for item_418 in var_416 {
{
let mut object_419 = array_417.value().start_object();
crate::json_ser::serialize_structure_crate_model_segment_group(
&mut object_419,
item_418,
)?;
object_419.finish();
}
}
array_417.finish();
}
if let Some(var_420) = &input.include {
object.key("Include").string(var_420.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_421) = &input.endpoint {
let mut object_422 = object.key("Endpoint").start_object();
crate::json_ser::serialize_structure_crate_model_public_endpoint(&mut object_422, var_421)?;
object_422.finish();
}
if let Some(var_423) = &input.events {
let mut object_424 = object.key("Events").start_object();
for (key_425, value_426) in var_423 {
{
let mut object_427 = object_424.key(key_425).start_object();
crate::json_ser::serialize_structure_crate_model_event(&mut object_427, value_426)?;
object_427.finish();
}
}
object_424.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_428) = &input.body_override {
object.key("BodyOverride").string(var_428);
}
if let Some(var_429) = &input.channel_type {
object.key("ChannelType").string(var_429.as_str());
}
if let Some(var_430) = &input.context {
let mut object_431 = object.key("Context").start_object();
for (key_432, value_433) in var_430 {
{
object_431.key(key_432).string(value_433);
}
}
object_431.finish();
}
if let Some(var_434) = &input.raw_content {
object.key("RawContent").string(var_434);
}
if let Some(var_435) = &input.substitutions {
let mut object_436 = object.key("Substitutions").start_object();
for (key_437, value_438) in var_435 {
{
let mut array_439 = object_436.key(key_437).start_array();
for item_440 in value_438 {
{
array_439.value().string(item_440);
}
}
array_439.finish();
}
}
object_436.finish();
}
if let Some(var_441) = &input.title_override {
object.key("TitleOverride").string(var_441);
}
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_442) = &input.body_override {
object.key("BodyOverride").string(var_442);
}
if let Some(var_443) = &input.context {
let mut object_444 = object.key("Context").start_object();
for (key_445, value_446) in var_443 {
{
object_444.key(key_445).string(value_446);
}
}
object_444.finish();
}
if let Some(var_447) = &input.raw_content {
object.key("RawContent").string(var_447);
}
if let Some(var_448) = &input.substitutions {
let mut object_449 = object.key("Substitutions").start_object();
for (key_450, value_451) in var_448 {
{
let mut array_452 = object_449.key(key_450).start_array();
for item_453 in value_451 {
{
array_452.value().string(item_453);
}
}
array_452.finish();
}
}
object_449.finish();
}
if let Some(var_454) = &input.title_override {
object.key("TitleOverride").string(var_454);
}
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_455) = &input.adm_message {
let mut object_456 = object.key("ADMMessage").start_object();
crate::json_ser::serialize_structure_crate_model_adm_message(&mut object_456, var_455)?;
object_456.finish();
}
if let Some(var_457) = &input.apns_message {
let mut object_458 = object.key("APNSMessage").start_object();
crate::json_ser::serialize_structure_crate_model_apns_message(&mut object_458, var_457)?;
object_458.finish();
}
if let Some(var_459) = &input.baidu_message {
let mut object_460 = object.key("BaiduMessage").start_object();
crate::json_ser::serialize_structure_crate_model_baidu_message(&mut object_460, var_459)?;
object_460.finish();
}
if let Some(var_461) = &input.default_message {
let mut object_462 = object.key("DefaultMessage").start_object();
crate::json_ser::serialize_structure_crate_model_default_message(&mut object_462, var_461)?;
object_462.finish();
}
if let Some(var_463) = &input.default_push_notification_message {
let mut object_464 = object.key("DefaultPushNotificationMessage").start_object();
crate::json_ser::serialize_structure_crate_model_default_push_notification_message(
&mut object_464,
var_463,
)?;
object_464.finish();
}
if let Some(var_465) = &input.email_message {
let mut object_466 = object.key("EmailMessage").start_object();
crate::json_ser::serialize_structure_crate_model_email_message(&mut object_466, var_465)?;
object_466.finish();
}
if let Some(var_467) = &input.gcm_message {
let mut object_468 = object.key("GCMMessage").start_object();
crate::json_ser::serialize_structure_crate_model_gcm_message(&mut object_468, var_467)?;
object_468.finish();
}
if let Some(var_469) = &input.sms_message {
let mut object_470 = object.key("SMSMessage").start_object();
crate::json_ser::serialize_structure_crate_model_sms_message(&mut object_470, var_469)?;
object_470.finish();
}
if let Some(var_471) = &input.voice_message {
let mut object_472 = object.key("VoiceMessage").start_object();
crate::json_ser::serialize_structure_crate_model_voice_message(&mut object_472, var_471)?;
object_472.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_473) = &input.app_version {
object.key("AppVersion").string(var_473);
}
if let Some(var_474) = &input.locale {
object.key("Locale").string(var_474);
}
if let Some(var_475) = &input.make {
object.key("Make").string(var_475);
}
if let Some(var_476) = &input.model {
object.key("Model").string(var_476);
}
if let Some(var_477) = &input.model_version {
object.key("ModelVersion").string(var_477);
}
if let Some(var_478) = &input.platform {
object.key("Platform").string(var_478);
}
if let Some(var_479) = &input.platform_version {
object.key("PlatformVersion").string(var_479);
}
if let Some(var_480) = &input.timezone {
object.key("Timezone").string(var_480);
}
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_481) = &input.city {
object.key("City").string(var_481);
}
if let Some(var_482) = &input.country {
object.key("Country").string(var_482);
}
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_483) = &input.postal_code {
object.key("PostalCode").string(var_483);
}
if let Some(var_484) = &input.region {
object.key("Region").string(var_484);
}
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_485) = &input.user_attributes {
let mut object_486 = object.key("UserAttributes").start_object();
for (key_487, value_488) in var_485 {
{
let mut array_489 = object_486.key(key_487).start_array();
for item_490 in value_488 {
{
array_489.value().string(item_490);
}
}
array_489.finish();
}
}
object_486.finish();
}
if let Some(var_491) = &input.user_id {
object.key("UserId").string(var_491);
}
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_492) = &input.address {
object.key("Address").string(var_492);
}
if let Some(var_493) = &input.attributes {
let mut object_494 = object.key("Attributes").start_object();
for (key_495, value_496) in var_493 {
{
let mut array_497 = object_494.key(key_495).start_array();
for item_498 in value_496 {
{
array_497.value().string(item_498);
}
}
array_497.finish();
}
}
object_494.finish();
}
if let Some(var_499) = &input.channel_type {
object.key("ChannelType").string(var_499.as_str());
}
if let Some(var_500) = &input.demographic {
let mut object_501 = object.key("Demographic").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_demographic(
&mut object_501,
var_500,
)?;
object_501.finish();
}
if let Some(var_502) = &input.effective_date {
object.key("EffectiveDate").string(var_502);
}
if let Some(var_503) = &input.endpoint_status {
object.key("EndpointStatus").string(var_503);
}
if let Some(var_504) = &input.id {
object.key("Id").string(var_504);
}
if let Some(var_505) = &input.location {
let mut object_506 = object.key("Location").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_location(
&mut object_506,
var_505,
)?;
object_506.finish();
}
if let Some(var_507) = &input.metrics {
let mut object_508 = object.key("Metrics").start_object();
for (key_509, value_510) in var_507 {
{
object_508.key(key_509).number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*value_510).into()),
);
}
}
object_508.finish();
}
if let Some(var_511) = &input.opt_out {
object.key("OptOut").string(var_511);
}
if let Some(var_512) = &input.request_id {
object.key("RequestId").string(var_512);
}
if let Some(var_513) = &input.user {
let mut object_514 = object.key("User").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_user(&mut object_514, var_513)?;
object_514.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_515) = &input.action {
object.key("Action").string(var_515.as_str());
}
if let Some(var_516) = &input.body {
object.key("Body").string(var_516);
}
if let Some(var_517) = &input.image_icon_url {
object.key("ImageIconUrl").string(var_517);
}
if let Some(var_518) = &input.image_small_icon_url {
object.key("ImageSmallIconUrl").string(var_518);
}
if let Some(var_519) = &input.image_url {
object.key("ImageUrl").string(var_519);
}
if let Some(var_520) = &input.json_body {
object.key("JsonBody").string(var_520);
}
if let Some(var_521) = &input.media_url {
object.key("MediaUrl").string(var_521);
}
if let Some(var_522) = &input.raw_content {
object.key("RawContent").string(var_522);
}
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_523) = &input.title {
object.key("Title").string(var_523);
}
if let Some(var_524) = &input.url {
object.key("Url").string(var_524);
}
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_525) = &input.data {
object.key("Data").string(var_525);
}
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_526) = &input.body {
object.key("Body").string(var_526);
}
if let Some(var_527) = &input.from_address {
object.key("FromAddress").string(var_527);
}
if let Some(var_528) = &input.html_body {
object.key("HtmlBody").string(var_528);
}
if let Some(var_529) = &input.title {
object.key("Title").string(var_529);
}
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_530) = &input.body {
object.key("Body").string(var_530);
}
if let Some(var_531) = &input.message_type {
object.key("MessageType").string(var_531.as_str());
}
if let Some(var_532) = &input.origination_number {
object.key("OriginationNumber").string(var_532);
}
if let Some(var_533) = &input.sender_id {
object.key("SenderId").string(var_533);
}
if let Some(var_534) = &input.entity_id {
object.key("EntityId").string(var_534);
}
if let Some(var_535) = &input.template_id {
object.key("TemplateId").string(var_535);
}
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_536) = &input.body {
object.key("Body").string(var_536);
}
if let Some(var_537) = &input.content {
let mut array_538 = object.key("Content").start_array();
for item_539 in var_537 {
{
let mut object_540 = array_538.value().start_object();
crate::json_ser::serialize_structure_crate_model_in_app_message_content(
&mut object_540,
item_539,
)?;
object_540.finish();
}
}
array_538.finish();
}
if let Some(var_541) = &input.custom_config {
let mut object_542 = object.key("CustomConfig").start_object();
for (key_543, value_544) in var_541 {
{
object_542.key(key_543).string(value_544);
}
}
object_542.finish();
}
if let Some(var_545) = &input.layout {
object.key("Layout").string(var_545.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_546) = &input.dimensions {
let mut object_547 = object.key("Dimensions").start_object();
crate::json_ser::serialize_structure_crate_model_event_dimensions(
&mut object_547,
var_546,
)?;
object_547.finish();
}
if let Some(var_548) = &input.filter_type {
object.key("FilterType").string(var_548.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_549) = &input.name {
object.key("Name").string(var_549);
}
if let Some(var_550) = &input.version {
object.key("Version").string(var_550);
}
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_551) = &input.alignment {
object.key("Alignment").string(var_551.as_str());
}
if let Some(var_552) = &input.body {
object.key("Body").string(var_552);
}
if let Some(var_553) = &input.text_color {
object.key("TextColor").string(var_553);
}
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_554) = &input.alignment {
object.key("Alignment").string(var_554.as_str());
}
if let Some(var_555) = &input.header {
object.key("Header").string(var_555);
}
if let Some(var_556) = &input.text_color {
object.key("TextColor").string(var_556);
}
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_557) = &input.android {
let mut object_558 = object.key("Android").start_object();
crate::json_ser::serialize_structure_crate_model_override_button_configuration(
&mut object_558,
var_557,
)?;
object_558.finish();
}
if let Some(var_559) = &input.default_config {
let mut object_560 = object.key("DefaultConfig").start_object();
crate::json_ser::serialize_structure_crate_model_default_button_configuration(
&mut object_560,
var_559,
)?;
object_560.finish();
}
if let Some(var_561) = &input.ios {
let mut object_562 = object.key("IOS").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.web {
let mut object_564 = object.key("Web").start_object();
crate::json_ser::serialize_structure_crate_model_override_button_configuration(
&mut object_564,
var_563,
)?;
object_564.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_565) = &input.delivery_uri {
object.key("DeliveryUri").string(var_565);
}
if let Some(var_566) = &input.endpoint_types {
let mut array_567 = object.key("EndpointTypes").start_array();
for item_568 in var_566 {
{
array_567.value().string(item_568.as_str());
}
}
array_567.finish();
}
if let Some(var_569) = &input.message_config {
let mut object_570 = object.key("MessageConfig").start_object();
crate::json_ser::serialize_structure_crate_model_journey_custom_message(
&mut object_570,
var_569,
)?;
object_570.finish();
}
if let Some(var_571) = &input.next_activity {
object.key("NextActivity").string(var_571);
}
if let Some(var_572) = &input.template_name {
object.key("TemplateName").string(var_572);
}
if let Some(var_573) = &input.template_version {
object.key("TemplateVersion").string(var_573);
}
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_574) = &input.condition {
let mut object_575 = object.key("Condition").start_object();
crate::json_ser::serialize_structure_crate_model_condition(&mut object_575, var_574)?;
object_575.finish();
}
if let Some(var_576) = &input.evaluation_wait_time {
let mut object_577 = object.key("EvaluationWaitTime").start_object();
crate::json_ser::serialize_structure_crate_model_wait_time(&mut object_577, var_576)?;
object_577.finish();
}
if let Some(var_578) = &input.false_activity {
object.key("FalseActivity").string(var_578);
}
if let Some(var_579) = &input.true_activity {
object.key("TrueActivity").string(var_579);
}
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_580) = &input.message_config {
let mut object_581 = object.key("MessageConfig").start_object();
crate::json_ser::serialize_structure_crate_model_journey_email_message(
&mut object_581,
var_580,
)?;
object_581.finish();
}
if let Some(var_582) = &input.next_activity {
object.key("NextActivity").string(var_582);
}
if let Some(var_583) = &input.template_name {
object.key("TemplateName").string(var_583);
}
if let Some(var_584) = &input.template_version {
object.key("TemplateVersion").string(var_584);
}
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_585) = &input.next_activity {
object.key("NextActivity").string(var_585);
}
{
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_586) = &input.branches {
let mut array_587 = object.key("Branches").start_array();
for item_588 in var_586 {
{
let mut object_589 = array_587.value().start_object();
crate::json_ser::serialize_structure_crate_model_multi_conditional_branch(
&mut object_589,
item_588,
)?;
object_589.finish();
}
}
array_587.finish();
}
if let Some(var_590) = &input.default_activity {
object.key("DefaultActivity").string(var_590);
}
if let Some(var_591) = &input.evaluation_wait_time {
let mut object_592 = object.key("EvaluationWaitTime").start_object();
crate::json_ser::serialize_structure_crate_model_wait_time(&mut object_592, var_591)?;
object_592.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_593) = &input.message_config {
let mut object_594 = object.key("MessageConfig").start_object();
crate::json_ser::serialize_structure_crate_model_journey_push_message(
&mut object_594,
var_593,
)?;
object_594.finish();
}
if let Some(var_595) = &input.next_activity {
object.key("NextActivity").string(var_595);
}
if let Some(var_596) = &input.template_name {
object.key("TemplateName").string(var_596);
}
if let Some(var_597) = &input.template_version {
object.key("TemplateVersion").string(var_597);
}
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_598) = &input.branches {
let mut array_599 = object.key("Branches").start_array();
for item_600 in var_598 {
{
let mut object_601 = array_599.value().start_object();
crate::json_ser::serialize_structure_crate_model_random_split_entry(
&mut object_601,
item_600,
)?;
object_601.finish();
}
}
array_599.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_602) = &input.message_config {
let mut object_603 = object.key("MessageConfig").start_object();
crate::json_ser::serialize_structure_crate_model_journey_sms_message(
&mut object_603,
var_602,
)?;
object_603.finish();
}
if let Some(var_604) = &input.next_activity {
object.key("NextActivity").string(var_604);
}
if let Some(var_605) = &input.template_name {
object.key("TemplateName").string(var_605);
}
if let Some(var_606) = &input.template_version {
object.key("TemplateVersion").string(var_606);
}
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_607) = &input.next_activity {
object.key("NextActivity").string(var_607);
}
if let Some(var_608) = &input.wait_time {
let mut object_609 = object.key("WaitTime").start_object();
crate::json_ser::serialize_structure_crate_model_wait_time(&mut object_609, var_608)?;
object_609.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_610) = &input.next_activity {
object.key("NextActivity").string(var_610);
}
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_611) = &input.event_filter {
let mut object_612 = object.key("EventFilter").start_object();
crate::json_ser::serialize_structure_crate_model_event_filter(&mut object_612, var_611)?;
object_612.finish();
}
if let Some(var_613) = &input.segment_id {
object.key("SegmentId").string(var_613);
}
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_614) = &input.segment_id {
object.key("SegmentId").string(var_614);
}
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_615) = &input.attribute_type {
object.key("AttributeType").string(var_615.as_str());
}
if let Some(var_616) = &input.values {
let mut array_617 = object.key("Values").start_array();
for item_618 in var_616 {
{
array_617.value().string(item_618);
}
}
array_617.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_619) = &input.recency {
let mut object_620 = object.key("Recency").start_object();
crate::json_ser::serialize_structure_crate_model_recency_dimension(
&mut object_620,
var_619,
)?;
object_620.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_621) = &input.app_version {
let mut object_622 = object.key("AppVersion").start_object();
crate::json_ser::serialize_structure_crate_model_set_dimension(&mut object_622, var_621)?;
object_622.finish();
}
if let Some(var_623) = &input.channel {
let mut object_624 = object.key("Channel").start_object();
crate::json_ser::serialize_structure_crate_model_set_dimension(&mut object_624, var_623)?;
object_624.finish();
}
if let Some(var_625) = &input.device_type {
let mut object_626 = object.key("DeviceType").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.make {
let mut object_628 = object.key("Make").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.model {
let mut object_630 = object.key("Model").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.platform {
let mut object_632 = object.key("Platform").start_object();
crate::json_ser::serialize_structure_crate_model_set_dimension(&mut object_632, var_631)?;
object_632.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_633) = &input.country {
let mut object_634 = object.key("Country").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.gps_point {
let mut object_636 = object.key("GPSPoint").start_object();
crate::json_ser::serialize_structure_crate_model_gps_point_dimension(
&mut object_636,
var_635,
)?;
object_636.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_637) = &input.comparison_operator {
object.key("ComparisonOperator").string(var_637);
}
{
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_638) = &input.dimensions {
let mut array_639 = object.key("Dimensions").start_array();
for item_640 in var_638 {
{
let mut object_641 = array_639.value().start_object();
crate::json_ser::serialize_structure_crate_model_segment_dimensions(
&mut object_641,
item_640,
)?;
object_641.finish();
}
}
array_639.finish();
}
if let Some(var_642) = &input.source_segments {
let mut array_643 = object.key("SourceSegments").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_reference(
&mut object_645,
item_644,
)?;
object_645.finish();
}
}
array_643.finish();
}
if let Some(var_646) = &input.source_type {
object.key("SourceType").string(var_646.as_str());
}
if let Some(var_647) = &input.r#type {
object.key("Type").string(var_647.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_648) = &input.address {
object.key("Address").string(var_648);
}
if let Some(var_649) = &input.attributes {
let mut object_650 = object.key("Attributes").start_object();
for (key_651, value_652) in var_649 {
{
let mut array_653 = object_650.key(key_651).start_array();
for item_654 in value_652 {
{
array_653.value().string(item_654);
}
}
array_653.finish();
}
}
object_650.finish();
}
if let Some(var_655) = &input.channel_type {
object.key("ChannelType").string(var_655.as_str());
}
if let Some(var_656) = &input.demographic {
let mut object_657 = object.key("Demographic").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_demographic(
&mut object_657,
var_656,
)?;
object_657.finish();
}
if let Some(var_658) = &input.effective_date {
object.key("EffectiveDate").string(var_658);
}
if let Some(var_659) = &input.endpoint_status {
object.key("EndpointStatus").string(var_659);
}
if let Some(var_660) = &input.location {
let mut object_661 = object.key("Location").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_location(
&mut object_661,
var_660,
)?;
object_661.finish();
}
if let Some(var_662) = &input.metrics {
let mut object_663 = object.key("Metrics").start_object();
for (key_664, value_665) in var_662 {
{
object_663.key(key_664).number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*value_665).into()),
);
}
}
object_663.finish();
}
if let Some(var_666) = &input.opt_out {
object.key("OptOut").string(var_666);
}
if let Some(var_667) = &input.request_id {
object.key("RequestId").string(var_667);
}
if let Some(var_668) = &input.user {
let mut object_669 = object.key("User").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_user(&mut object_669, var_668)?;
object_669.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_670) = &input.app_package_name {
object.key("AppPackageName").string(var_670);
}
if let Some(var_671) = &input.app_title {
object.key("AppTitle").string(var_671);
}
if let Some(var_672) = &input.app_version_code {
object.key("AppVersionCode").string(var_672);
}
if let Some(var_673) = &input.attributes {
let mut object_674 = object.key("Attributes").start_object();
for (key_675, value_676) in var_673 {
{
object_674.key(key_675).string(value_676);
}
}
object_674.finish();
}
if let Some(var_677) = &input.client_sdk_version {
object.key("ClientSdkVersion").string(var_677);
}
if let Some(var_678) = &input.event_type {
object.key("EventType").string(var_678);
}
if let Some(var_679) = &input.metrics {
let mut object_680 = object.key("Metrics").start_object();
for (key_681, value_682) in var_679 {
{
object_680.key(key_681).number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*value_682).into()),
);
}
}
object_680.finish();
}
if let Some(var_683) = &input.sdk_name {
object.key("SdkName").string(var_683);
}
if let Some(var_684) = &input.session {
let mut object_685 = object.key("Session").start_object();
crate::json_ser::serialize_structure_crate_model_session(&mut object_685, var_684)?;
object_685.finish();
}
if let Some(var_686) = &input.timestamp {
object.key("Timestamp").string(var_686);
}
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_687) = &input.action {
object.key("Action").string(var_687.as_str());
}
if let Some(var_688) = &input.body {
object.key("Body").string(var_688);
}
if let Some(var_689) = &input.consolidation_key {
object.key("ConsolidationKey").string(var_689);
}
if let Some(var_690) = &input.data {
let mut object_691 = object.key("Data").start_object();
for (key_692, value_693) in var_690 {
{
object_691.key(key_692).string(value_693);
}
}
object_691.finish();
}
if let Some(var_694) = &input.expires_after {
object.key("ExpiresAfter").string(var_694);
}
if let Some(var_695) = &input.icon_reference {
object.key("IconReference").string(var_695);
}
if let Some(var_696) = &input.image_icon_url {
object.key("ImageIconUrl").string(var_696);
}
if let Some(var_697) = &input.image_url {
object.key("ImageUrl").string(var_697);
}
if let Some(var_698) = &input.md5 {
object.key("MD5").string(var_698);
}
if let Some(var_699) = &input.raw_content {
object.key("RawContent").string(var_699);
}
if input.silent_push {
object.key("SilentPush").boolean(input.silent_push);
}
if let Some(var_700) = &input.small_image_icon_url {
object.key("SmallImageIconUrl").string(var_700);
}
if let Some(var_701) = &input.sound {
object.key("Sound").string(var_701);
}
if let Some(var_702) = &input.substitutions {
let mut object_703 = object.key("Substitutions").start_object();
for (key_704, value_705) in var_702 {
{
let mut array_706 = object_703.key(key_704).start_array();
for item_707 in value_705 {
{
array_706.value().string(item_707);
}
}
array_706.finish();
}
}
object_703.finish();
}
if let Some(var_708) = &input.title {
object.key("Title").string(var_708);
}
if let Some(var_709) = &input.url {
object.key("Url").string(var_709);
}
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_710) = &input.apns_push_type {
object.key("APNSPushType").string(var_710);
}
if let Some(var_711) = &input.action {
object.key("Action").string(var_711.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_712) = &input.body {
object.key("Body").string(var_712);
}
if let Some(var_713) = &input.category {
object.key("Category").string(var_713);
}
if let Some(var_714) = &input.collapse_id {
object.key("CollapseId").string(var_714);
}
if let Some(var_715) = &input.data {
let mut object_716 = object.key("Data").start_object();
for (key_717, value_718) in var_715 {
{
object_716.key(key_717).string(value_718);
}
}
object_716.finish();
}
if let Some(var_719) = &input.media_url {
object.key("MediaUrl").string(var_719);
}
if let Some(var_720) = &input.preferred_authentication_method {
object.key("PreferredAuthenticationMethod").string(var_720);
}
if let Some(var_721) = &input.priority {
object.key("Priority").string(var_721);
}
if let Some(var_722) = &input.raw_content {
object.key("RawContent").string(var_722);
}
if input.silent_push {
object.key("SilentPush").boolean(input.silent_push);
}
if let Some(var_723) = &input.sound {
object.key("Sound").string(var_723);
}
if let Some(var_724) = &input.substitutions {
let mut object_725 = object.key("Substitutions").start_object();
for (key_726, value_727) in var_724 {
{
let mut array_728 = object_725.key(key_726).start_array();
for item_729 in value_727 {
{
array_728.value().string(item_729);
}
}
array_728.finish();
}
}
object_725.finish();
}
if let Some(var_730) = &input.thread_id {
object.key("ThreadId").string(var_730);
}
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_731) = &input.title {
object.key("Title").string(var_731);
}
if let Some(var_732) = &input.url {
object.key("Url").string(var_732);
}
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_733) = &input.action {
object.key("Action").string(var_733.as_str());
}
if let Some(var_734) = &input.body {
object.key("Body").string(var_734);
}
if let Some(var_735) = &input.data {
let mut object_736 = object.key("Data").start_object();
for (key_737, value_738) in var_735 {
{
object_736.key(key_737).string(value_738);
}
}
object_736.finish();
}
if let Some(var_739) = &input.icon_reference {
object.key("IconReference").string(var_739);
}
if let Some(var_740) = &input.image_icon_url {
object.key("ImageIconUrl").string(var_740);
}
if let Some(var_741) = &input.image_url {
object.key("ImageUrl").string(var_741);
}
if let Some(var_742) = &input.raw_content {
object.key("RawContent").string(var_742);
}
if input.silent_push {
object.key("SilentPush").boolean(input.silent_push);
}
if let Some(var_743) = &input.small_image_icon_url {
object.key("SmallImageIconUrl").string(var_743);
}
if let Some(var_744) = &input.sound {
object.key("Sound").string(var_744);
}
if let Some(var_745) = &input.substitutions {
let mut object_746 = object.key("Substitutions").start_object();
for (key_747, value_748) in var_745 {
{
let mut array_749 = object_746.key(key_747).start_array();
for item_750 in value_748 {
{
array_749.value().string(item_750);
}
}
array_749.finish();
}
}
object_746.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_751) = &input.title {
object.key("Title").string(var_751);
}
if let Some(var_752) = &input.url {
object.key("Url").string(var_752);
}
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_753) = &input.body {
object.key("Body").string(var_753);
}
if let Some(var_754) = &input.substitutions {
let mut object_755 = object.key("Substitutions").start_object();
for (key_756, value_757) in var_754 {
{
let mut array_758 = object_755.key(key_756).start_array();
for item_759 in value_757 {
{
array_758.value().string(item_759);
}
}
array_758.finish();
}
}
object_755.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_760) = &input.action {
object.key("Action").string(var_760.as_str());
}
if let Some(var_761) = &input.body {
object.key("Body").string(var_761);
}
if let Some(var_762) = &input.data {
let mut object_763 = object.key("Data").start_object();
for (key_764, value_765) in var_762 {
{
object_763.key(key_764).string(value_765);
}
}
object_763.finish();
}
if input.silent_push {
object.key("SilentPush").boolean(input.silent_push);
}
if let Some(var_766) = &input.substitutions {
let mut object_767 = object.key("Substitutions").start_object();
for (key_768, value_769) in var_766 {
{
let mut array_770 = object_767.key(key_768).start_array();
for item_771 in value_769 {
{
array_770.value().string(item_771);
}
}
array_770.finish();
}
}
object_767.finish();
}
if let Some(var_772) = &input.title {
object.key("Title").string(var_772);
}
if let Some(var_773) = &input.url {
object.key("Url").string(var_773);
}
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_774) = &input.body {
object.key("Body").string(var_774);
}
if let Some(var_775) = &input.feedback_forwarding_address {
object.key("FeedbackForwardingAddress").string(var_775);
}
if let Some(var_776) = &input.from_address {
object.key("FromAddress").string(var_776);
}
if let Some(var_777) = &input.raw_email {
let mut object_778 = object.key("RawEmail").start_object();
crate::json_ser::serialize_structure_crate_model_raw_email(&mut object_778, var_777)?;
object_778.finish();
}
if let Some(var_779) = &input.reply_to_addresses {
let mut array_780 = object.key("ReplyToAddresses").start_array();
for item_781 in var_779 {
{
array_780.value().string(item_781);
}
}
array_780.finish();
}
if let Some(var_782) = &input.simple_email {
let mut object_783 = object.key("SimpleEmail").start_object();
crate::json_ser::serialize_structure_crate_model_simple_email(&mut object_783, var_782)?;
object_783.finish();
}
if let Some(var_784) = &input.substitutions {
let mut object_785 = object.key("Substitutions").start_object();
for (key_786, value_787) in var_784 {
{
let mut array_788 = object_785.key(key_786).start_array();
for item_789 in value_787 {
{
array_788.value().string(item_789);
}
}
array_788.finish();
}
}
object_785.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_790) = &input.action {
object.key("Action").string(var_790.as_str());
}
if let Some(var_791) = &input.body {
object.key("Body").string(var_791);
}
if let Some(var_792) = &input.collapse_key {
object.key("CollapseKey").string(var_792);
}
if let Some(var_793) = &input.data {
let mut object_794 = object.key("Data").start_object();
for (key_795, value_796) in var_793 {
{
object_794.key(key_795).string(value_796);
}
}
object_794.finish();
}
if let Some(var_797) = &input.icon_reference {
object.key("IconReference").string(var_797);
}
if let Some(var_798) = &input.image_icon_url {
object.key("ImageIconUrl").string(var_798);
}
if let Some(var_799) = &input.image_url {
object.key("ImageUrl").string(var_799);
}
if let Some(var_800) = &input.priority {
object.key("Priority").string(var_800);
}
if let Some(var_801) = &input.raw_content {
object.key("RawContent").string(var_801);
}
if let Some(var_802) = &input.restricted_package_name {
object.key("RestrictedPackageName").string(var_802);
}
if input.silent_push {
object.key("SilentPush").boolean(input.silent_push);
}
if let Some(var_803) = &input.small_image_icon_url {
object.key("SmallImageIconUrl").string(var_803);
}
if let Some(var_804) = &input.sound {
object.key("Sound").string(var_804);
}
if let Some(var_805) = &input.substitutions {
let mut object_806 = object.key("Substitutions").start_object();
for (key_807, value_808) in var_805 {
{
let mut array_809 = object_806.key(key_807).start_array();
for item_810 in value_808 {
{
array_809.value().string(item_810);
}
}
array_809.finish();
}
}
object_806.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_811) = &input.title {
object.key("Title").string(var_811);
}
if let Some(var_812) = &input.url {
object.key("Url").string(var_812);
}
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_813) = &input.body {
object.key("Body").string(var_813);
}
if let Some(var_814) = &input.keyword {
object.key("Keyword").string(var_814);
}
if let Some(var_815) = &input.media_url {
object.key("MediaUrl").string(var_815);
}
if let Some(var_816) = &input.message_type {
object.key("MessageType").string(var_816.as_str());
}
if let Some(var_817) = &input.origination_number {
object.key("OriginationNumber").string(var_817);
}
if let Some(var_818) = &input.sender_id {
object.key("SenderId").string(var_818);
}
if let Some(var_819) = &input.substitutions {
let mut object_820 = object.key("Substitutions").start_object();
for (key_821, value_822) in var_819 {
{
let mut array_823 = object_820.key(key_821).start_array();
for item_824 in value_822 {
{
array_823.value().string(item_824);
}
}
array_823.finish();
}
}
object_820.finish();
}
if let Some(var_825) = &input.entity_id {
object.key("EntityId").string(var_825);
}
if let Some(var_826) = &input.template_id {
object.key("TemplateId").string(var_826);
}
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_827) = &input.body {
object.key("Body").string(var_827);
}
if let Some(var_828) = &input.language_code {
object.key("LanguageCode").string(var_828);
}
if let Some(var_829) = &input.origination_number {
object.key("OriginationNumber").string(var_829);
}
if let Some(var_830) = &input.substitutions {
let mut object_831 = object.key("Substitutions").start_object();
for (key_832, value_833) in var_830 {
{
let mut array_834 = object_831.key(key_832).start_array();
for item_835 in value_833 {
{
array_834.value().string(item_835);
}
}
array_834.finish();
}
}
object_831.finish();
}
if let Some(var_836) = &input.voice_id {
object.key("VoiceId").string(var_836);
}
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_837) = &input.attributes {
let mut object_838 = object.key("Attributes").start_object();
for (key_839, value_840) in var_837 {
{
let mut object_841 = object_838.key(key_839).start_object();
crate::json_ser::serialize_structure_crate_model_attribute_dimension(
&mut object_841,
value_840,
)?;
object_841.finish();
}
}
object_838.finish();
}
if let Some(var_842) = &input.event_type {
let mut object_843 = object.key("EventType").start_object();
crate::json_ser::serialize_structure_crate_model_set_dimension(&mut object_843, var_842)?;
object_843.finish();
}
if let Some(var_844) = &input.metrics {
let mut object_845 = object.key("Metrics").start_object();
for (key_846, value_847) in var_844 {
{
let mut object_848 = object_845.key(key_846).start_object();
crate::json_ser::serialize_structure_crate_model_metric_dimension(
&mut object_848,
value_847,
)?;
object_848.finish();
}
}
object_845.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_849) = &input.button_action {
object.key("ButtonAction").string(var_849.as_str());
}
if let Some(var_850) = &input.link {
object.key("Link").string(var_850);
}
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_851) = &input.background_color {
object.key("BackgroundColor").string(var_851);
}
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_852) = &input.button_action {
object.key("ButtonAction").string(var_852.as_str());
}
if let Some(var_853) = &input.link {
object.key("Link").string(var_853);
}
if let Some(var_854) = &input.text {
object.key("Text").string(var_854);
}
if let Some(var_855) = &input.text_color {
object.key("TextColor").string(var_855);
}
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_856) = &input.data {
object.key("Data").string(var_856);
}
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_857) = &input.conditions {
let mut array_858 = object.key("Conditions").start_array();
for item_859 in var_857 {
{
let mut object_860 = array_858.value().start_object();
crate::json_ser::serialize_structure_crate_model_simple_condition(
&mut object_860,
item_859,
)?;
object_860.finish();
}
}
array_858.finish();
}
if let Some(var_861) = &input.operator {
object.key("Operator").string(var_861.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_862) = &input.wait_for {
object.key("WaitFor").string(var_862);
}
if let Some(var_863) = &input.wait_until {
object.key("WaitUntil").string(var_863);
}
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_864) = &input.from_address {
object.key("FromAddress").string(var_864);
}
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_865) = &input.condition {
let mut object_866 = object.key("Condition").start_object();
crate::json_ser::serialize_structure_crate_model_simple_condition(
&mut object_866,
var_865,
)?;
object_866.finish();
}
if let Some(var_867) = &input.next_activity {
object.key("NextActivity").string(var_867);
}
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_868) = &input.time_to_live {
object.key("TimeToLive").string(var_868);
}
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_869) = &input.next_activity {
object.key("NextActivity").string(var_869);
}
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_870) = &input.message_type {
object.key("MessageType").string(var_870.as_str());
}
if let Some(var_871) = &input.origination_number {
object.key("OriginationNumber").string(var_871);
}
if let Some(var_872) = &input.sender_id {
object.key("SenderId").string(var_872);
}
if let Some(var_873) = &input.entity_id {
object.key("EntityId").string(var_873);
}
if let Some(var_874) = &input.template_id {
object.key("TemplateId").string(var_874);
}
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_875) = &input.dimensions {
let mut object_876 = object.key("Dimensions").start_object();
crate::json_ser::serialize_structure_crate_model_event_dimensions(
&mut object_876,
var_875,
)?;
object_876.finish();
}
if let Some(var_877) = &input.filter_type {
object.key("FilterType").string(var_877.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_878) = &input.duration {
object.key("Duration").string(var_878.as_str());
}
if let Some(var_879) = &input.recency_type {
object.key("RecencyType").string(var_879.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_880) = &input.dimension_type {
object.key("DimensionType").string(var_880.as_str());
}
if let Some(var_881) = &input.values {
let mut array_882 = object.key("Values").start_array();
for item_883 in var_881 {
{
array_882.value().string(item_883);
}
}
array_882.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_884) = &input.coordinates {
let mut object_885 = object.key("Coordinates").start_object();
crate::json_ser::serialize_structure_crate_model_gps_coordinates(&mut object_885, var_884)?;
object_885.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_886) = &input.id {
object.key("Id").string(var_886);
}
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_887) = &input.id {
object.key("Id").string(var_887);
}
if let Some(var_888) = &input.start_timestamp {
object.key("StartTimestamp").string(var_888);
}
if let Some(var_889) = &input.stop_timestamp {
object.key("StopTimestamp").string(var_889);
}
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_890) = &input.data {
object
.key("Data")
.string_unchecked(&aws_smithy_types::base64::encode(var_890));
}
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_891) = &input.html_part {
let mut object_892 = object.key("HtmlPart").start_object();
crate::json_ser::serialize_structure_crate_model_simple_email_part(
&mut object_892,
var_891,
)?;
object_892.finish();
}
if let Some(var_893) = &input.subject {
let mut object_894 = object.key("Subject").start_object();
crate::json_ser::serialize_structure_crate_model_simple_email_part(
&mut object_894,
var_893,
)?;
object_894.finish();
}
if let Some(var_895) = &input.text_part {
let mut object_896 = object.key("TextPart").start_object();
crate::json_ser::serialize_structure_crate_model_simple_email_part(
&mut object_896,
var_895,
)?;
object_896.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_897) = &input.event_condition {
let mut object_898 = object.key("EventCondition").start_object();
crate::json_ser::serialize_structure_crate_model_event_condition(&mut object_898, var_897)?;
object_898.finish();
}
if let Some(var_899) = &input.segment_condition {
let mut object_900 = object.key("SegmentCondition").start_object();
crate::json_ser::serialize_structure_crate_model_segment_condition(
&mut object_900,
var_899,
)?;
object_900.finish();
}
if let Some(var_901) = &input.segment_dimensions {
let mut object_902 = object.key("segmentDimensions").start_object();
crate::json_ser::serialize_structure_crate_model_segment_dimensions(
&mut object_902,
var_901,
)?;
object_902.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_903) = &input.charset {
object.key("Charset").string(var_903);
}
if let Some(var_904) = &input.data {
object.key("Data").string(var_904);
}
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_905) = &input.dimensions {
let mut object_906 = object.key("Dimensions").start_object();
crate::json_ser::serialize_structure_crate_model_event_dimensions(
&mut object_906,
var_905,
)?;
object_906.finish();
}
if let Some(var_907) = &input.message_activity {
object.key("MessageActivity").string(var_907);
}
Ok(())
}