aws-sdk-chime 0.24.0

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
pub fn serialize_structure_crate_input_associate_phone_numbers_with_voice_connector_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::AssociatePhoneNumbersWithVoiceConnectorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_1) = &input.e164_phone_numbers {
        let mut array_2 = object.key("E164PhoneNumbers").start_array();
        for item_3 in var_1 {
            {
                array_2.value().string(item_3.as_str());
            }
        }
        array_2.finish();
    }
    if let Some(var_4) = &input.force_associate {
        object.key("ForceAssociate").boolean(*var_4);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_associate_phone_numbers_with_voice_connector_group_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::AssociatePhoneNumbersWithVoiceConnectorGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_5) = &input.e164_phone_numbers {
        let mut array_6 = object.key("E164PhoneNumbers").start_array();
        for item_7 in var_5 {
            {
                array_6.value().string(item_7.as_str());
            }
        }
        array_6.finish();
    }
    if let Some(var_8) = &input.force_associate {
        object.key("ForceAssociate").boolean(*var_8);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_associate_phone_number_with_user_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::AssociatePhoneNumberWithUserInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_9) = &input.e164_phone_number {
        object.key("E164PhoneNumber").string(var_9.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_associate_signin_delegate_groups_with_account_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::AssociateSigninDelegateGroupsWithAccountInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_10) = &input.signin_delegate_groups {
        let mut array_11 = object.key("SigninDelegateGroups").start_array();
        for item_12 in var_10 {
            {
                #[allow(unused_mut)]
                let mut object_13 = array_11.value().start_object();
                crate::json_ser::serialize_structure_crate_model_signin_delegate_group(
                    &mut object_13,
                    item_12,
                )?;
                object_13.finish();
            }
        }
        array_11.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_batch_create_attendee_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::BatchCreateAttendeeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_14) = &input.attendees {
        let mut array_15 = object.key("Attendees").start_array();
        for item_16 in var_14 {
            {
                #[allow(unused_mut)]
                let mut object_17 = array_15.value().start_object();
                crate::json_ser::serialize_structure_crate_model_create_attendee_request_item(
                    &mut object_17,
                    item_16,
                )?;
                object_17.finish();
            }
        }
        array_15.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_batch_create_channel_membership_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::BatchCreateChannelMembershipInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_18) = &input.member_arns {
        let mut array_19 = object.key("MemberArns").start_array();
        for item_20 in var_18 {
            {
                array_19.value().string(item_20.as_str());
            }
        }
        array_19.finish();
    }
    if let Some(var_21) = &input.r#type {
        object.key("Type").string(var_21.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_batch_create_room_membership_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::BatchCreateRoomMembershipInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_22) = &input.membership_item_list {
        let mut array_23 = object.key("MembershipItemList").start_array();
        for item_24 in var_22 {
            {
                #[allow(unused_mut)]
                let mut object_25 = array_23.value().start_object();
                crate::json_ser::serialize_structure_crate_model_membership_item(
                    &mut object_25,
                    item_24,
                )?;
                object_25.finish();
            }
        }
        array_23.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_batch_delete_phone_number_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::BatchDeletePhoneNumberInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_26) = &input.phone_number_ids {
        let mut array_27 = object.key("PhoneNumberIds").start_array();
        for item_28 in var_26 {
            {
                array_27.value().string(item_28.as_str());
            }
        }
        array_27.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_batch_suspend_user_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::BatchSuspendUserInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_29) = &input.user_id_list {
        let mut array_30 = object.key("UserIdList").start_array();
        for item_31 in var_29 {
            {
                array_30.value().string(item_31.as_str());
            }
        }
        array_30.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_batch_unsuspend_user_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::BatchUnsuspendUserInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_32) = &input.user_id_list {
        let mut array_33 = object.key("UserIdList").start_array();
        for item_34 in var_32 {
            {
                array_33.value().string(item_34.as_str());
            }
        }
        array_33.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_batch_update_phone_number_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::BatchUpdatePhoneNumberInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_35) = &input.update_phone_number_request_items {
        let mut array_36 = object.key("UpdatePhoneNumberRequestItems").start_array();
        for item_37 in var_35 {
            {
                #[allow(unused_mut)]
                let mut object_38 = array_36.value().start_object();
                crate::json_ser::serialize_structure_crate_model_update_phone_number_request_item(
                    &mut object_38,
                    item_37,
                )?;
                object_38.finish();
            }
        }
        array_36.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_batch_update_user_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::BatchUpdateUserInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_39) = &input.update_user_request_items {
        let mut array_40 = object.key("UpdateUserRequestItems").start_array();
        for item_41 in var_39 {
            {
                #[allow(unused_mut)]
                let mut object_42 = array_40.value().start_object();
                crate::json_ser::serialize_structure_crate_model_update_user_request_item(
                    &mut object_42,
                    item_41,
                )?;
                object_42.finish();
            }
        }
        array_40.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_account_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateAccountInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_43) = &input.name {
        object.key("Name").string(var_43.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_app_instance_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateAppInstanceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_44) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_44.as_str());
    }
    if let Some(var_45) = &input.metadata {
        object.key("Metadata").string(var_45.as_str());
    }
    if let Some(var_46) = &input.name {
        object.key("Name").string(var_46.as_str());
    }
    if let Some(var_47) = &input.tags {
        let mut array_48 = object.key("Tags").start_array();
        for item_49 in var_47 {
            {
                #[allow(unused_mut)]
                let mut object_50 = array_48.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_50, item_49)?;
                object_50.finish();
            }
        }
        array_48.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_app_instance_admin_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateAppInstanceAdminInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_51) = &input.app_instance_admin_arn {
        object.key("AppInstanceAdminArn").string(var_51.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_app_instance_user_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateAppInstanceUserInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_52) = &input.app_instance_arn {
        object.key("AppInstanceArn").string(var_52.as_str());
    }
    if let Some(var_53) = &input.app_instance_user_id {
        object.key("AppInstanceUserId").string(var_53.as_str());
    }
    if let Some(var_54) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_54.as_str());
    }
    if let Some(var_55) = &input.metadata {
        object.key("Metadata").string(var_55.as_str());
    }
    if let Some(var_56) = &input.name {
        object.key("Name").string(var_56.as_str());
    }
    if let Some(var_57) = &input.tags {
        let mut array_58 = object.key("Tags").start_array();
        for item_59 in var_57 {
            {
                #[allow(unused_mut)]
                let mut object_60 = array_58.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_60, item_59)?;
                object_60.finish();
            }
        }
        array_58.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_attendee_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateAttendeeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_61) = &input.external_user_id {
        object.key("ExternalUserId").string(var_61.as_str());
    }
    if let Some(var_62) = &input.tags {
        let mut array_63 = object.key("Tags").start_array();
        for item_64 in var_62 {
            {
                #[allow(unused_mut)]
                let mut object_65 = array_63.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_65, item_64)?;
                object_65.finish();
            }
        }
        array_63.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_bot_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateBotInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_66) = &input.display_name {
        object.key("DisplayName").string(var_66.as_str());
    }
    if let Some(var_67) = &input.domain {
        object.key("Domain").string(var_67.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_channel_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateChannelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_68) = &input.app_instance_arn {
        object.key("AppInstanceArn").string(var_68.as_str());
    }
    if let Some(var_69) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_69.as_str());
    }
    if let Some(var_70) = &input.metadata {
        object.key("Metadata").string(var_70.as_str());
    }
    if let Some(var_71) = &input.mode {
        object.key("Mode").string(var_71.as_str());
    }
    if let Some(var_72) = &input.name {
        object.key("Name").string(var_72.as_str());
    }
    if let Some(var_73) = &input.privacy {
        object.key("Privacy").string(var_73.as_str());
    }
    if let Some(var_74) = &input.tags {
        let mut array_75 = object.key("Tags").start_array();
        for item_76 in var_74 {
            {
                #[allow(unused_mut)]
                let mut object_77 = array_75.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_77, item_76)?;
                object_77.finish();
            }
        }
        array_75.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_channel_ban_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateChannelBanInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_78) = &input.member_arn {
        object.key("MemberArn").string(var_78.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_channel_membership_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateChannelMembershipInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_79) = &input.member_arn {
        object.key("MemberArn").string(var_79.as_str());
    }
    if let Some(var_80) = &input.r#type {
        object.key("Type").string(var_80.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_channel_moderator_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateChannelModeratorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_81) = &input.channel_moderator_arn {
        object.key("ChannelModeratorArn").string(var_81.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_media_capture_pipeline_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateMediaCapturePipelineInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_82) = &input.chime_sdk_meeting_configuration {
        #[allow(unused_mut)]
        let mut object_83 = object.key("ChimeSdkMeetingConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_chime_sdk_meeting_configuration(
            &mut object_83,
            var_82,
        )?;
        object_83.finish();
    }
    if let Some(var_84) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_84.as_str());
    }
    if let Some(var_85) = &input.sink_arn {
        object.key("SinkArn").string(var_85.as_str());
    }
    if let Some(var_86) = &input.sink_type {
        object.key("SinkType").string(var_86.as_str());
    }
    if let Some(var_87) = &input.source_arn {
        object.key("SourceArn").string(var_87.as_str());
    }
    if let Some(var_88) = &input.source_type {
        object.key("SourceType").string(var_88.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_meeting_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateMeetingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_89) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_89.as_str());
    }
    if let Some(var_90) = &input.external_meeting_id {
        object.key("ExternalMeetingId").string(var_90.as_str());
    }
    if let Some(var_91) = &input.media_region {
        object.key("MediaRegion").string(var_91.as_str());
    }
    if let Some(var_92) = &input.meeting_host_id {
        object.key("MeetingHostId").string(var_92.as_str());
    }
    if let Some(var_93) = &input.notifications_configuration {
        #[allow(unused_mut)]
        let mut object_94 = object.key("NotificationsConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_meeting_notification_configuration(
            &mut object_94,
            var_93,
        )?;
        object_94.finish();
    }
    if let Some(var_95) = &input.tags {
        let mut array_96 = object.key("Tags").start_array();
        for item_97 in var_95 {
            {
                #[allow(unused_mut)]
                let mut object_98 = array_96.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_98, item_97)?;
                object_98.finish();
            }
        }
        array_96.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_meeting_dial_out_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateMeetingDialOutInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_99) = &input.from_phone_number {
        object.key("FromPhoneNumber").string(var_99.as_str());
    }
    if let Some(var_100) = &input.join_token {
        object.key("JoinToken").string(var_100.as_str());
    }
    if let Some(var_101) = &input.to_phone_number {
        object.key("ToPhoneNumber").string(var_101.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_meeting_with_attendees_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateMeetingWithAttendeesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_102) = &input.attendees {
        let mut array_103 = object.key("Attendees").start_array();
        for item_104 in var_102 {
            {
                #[allow(unused_mut)]
                let mut object_105 = array_103.value().start_object();
                crate::json_ser::serialize_structure_crate_model_create_attendee_request_item(
                    &mut object_105,
                    item_104,
                )?;
                object_105.finish();
            }
        }
        array_103.finish();
    }
    if let Some(var_106) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_106.as_str());
    }
    if let Some(var_107) = &input.external_meeting_id {
        object.key("ExternalMeetingId").string(var_107.as_str());
    }
    if let Some(var_108) = &input.media_region {
        object.key("MediaRegion").string(var_108.as_str());
    }
    if let Some(var_109) = &input.meeting_host_id {
        object.key("MeetingHostId").string(var_109.as_str());
    }
    if let Some(var_110) = &input.notifications_configuration {
        #[allow(unused_mut)]
        let mut object_111 = object.key("NotificationsConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_meeting_notification_configuration(
            &mut object_111,
            var_110,
        )?;
        object_111.finish();
    }
    if let Some(var_112) = &input.tags {
        let mut array_113 = object.key("Tags").start_array();
        for item_114 in var_112 {
            {
                #[allow(unused_mut)]
                let mut object_115 = array_113.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_115, item_114)?;
                object_115.finish();
            }
        }
        array_113.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_phone_number_order_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreatePhoneNumberOrderInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_116) = &input.e164_phone_numbers {
        let mut array_117 = object.key("E164PhoneNumbers").start_array();
        for item_118 in var_116 {
            {
                array_117.value().string(item_118.as_str());
            }
        }
        array_117.finish();
    }
    if let Some(var_119) = &input.product_type {
        object.key("ProductType").string(var_119.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_proxy_session_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateProxySessionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_120) = &input.capabilities {
        let mut array_121 = object.key("Capabilities").start_array();
        for item_122 in var_120 {
            {
                array_121.value().string(item_122.as_str());
            }
        }
        array_121.finish();
    }
    if let Some(var_123) = &input.expiry_minutes {
        object.key("ExpiryMinutes").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_123).into()),
        );
    }
    if let Some(var_124) = &input.geo_match_level {
        object.key("GeoMatchLevel").string(var_124.as_str());
    }
    if let Some(var_125) = &input.geo_match_params {
        #[allow(unused_mut)]
        let mut object_126 = object.key("GeoMatchParams").start_object();
        crate::json_ser::serialize_structure_crate_model_geo_match_params(
            &mut object_126,
            var_125,
        )?;
        object_126.finish();
    }
    if let Some(var_127) = &input.name {
        object.key("Name").string(var_127.as_str());
    }
    if let Some(var_128) = &input.number_selection_behavior {
        object
            .key("NumberSelectionBehavior")
            .string(var_128.as_str());
    }
    if let Some(var_129) = &input.participant_phone_numbers {
        let mut array_130 = object.key("ParticipantPhoneNumbers").start_array();
        for item_131 in var_129 {
            {
                array_130.value().string(item_131.as_str());
            }
        }
        array_130.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_room_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateRoomInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_132) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_132.as_str());
    }
    if let Some(var_133) = &input.name {
        object.key("Name").string(var_133.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_room_membership_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateRoomMembershipInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_134) = &input.member_id {
        object.key("MemberId").string(var_134.as_str());
    }
    if let Some(var_135) = &input.role {
        object.key("Role").string(var_135.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_sip_media_application_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateSipMediaApplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_136) = &input.aws_region {
        object.key("AwsRegion").string(var_136.as_str());
    }
    if let Some(var_137) = &input.endpoints {
        let mut array_138 = object.key("Endpoints").start_array();
        for item_139 in var_137 {
            {
                #[allow(unused_mut)]
                let mut object_140 = array_138.value().start_object();
                crate::json_ser::serialize_structure_crate_model_sip_media_application_endpoint(
                    &mut object_140,
                    item_139,
                )?;
                object_140.finish();
            }
        }
        array_138.finish();
    }
    if let Some(var_141) = &input.name {
        object.key("Name").string(var_141.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_sip_media_application_call_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateSipMediaApplicationCallInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_142) = &input.from_phone_number {
        object.key("FromPhoneNumber").string(var_142.as_str());
    }
    if let Some(var_143) = &input.sip_headers {
        #[allow(unused_mut)]
        let mut object_144 = object.key("SipHeaders").start_object();
        for (key_145, value_146) in var_143 {
            {
                object_144.key(key_145.as_str()).string(value_146.as_str());
            }
        }
        object_144.finish();
    }
    if let Some(var_147) = &input.to_phone_number {
        object.key("ToPhoneNumber").string(var_147.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_sip_rule_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateSipRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_148) = &input.disabled {
        object.key("Disabled").boolean(*var_148);
    }
    if let Some(var_149) = &input.name {
        object.key("Name").string(var_149.as_str());
    }
    if let Some(var_150) = &input.target_applications {
        let mut array_151 = object.key("TargetApplications").start_array();
        for item_152 in var_150 {
            {
                #[allow(unused_mut)]
                let mut object_153 = array_151.value().start_object();
                crate::json_ser::serialize_structure_crate_model_sip_rule_target_application(
                    &mut object_153,
                    item_152,
                )?;
                object_153.finish();
            }
        }
        array_151.finish();
    }
    if let Some(var_154) = &input.trigger_type {
        object.key("TriggerType").string(var_154.as_str());
    }
    if let Some(var_155) = &input.trigger_value {
        object.key("TriggerValue").string(var_155.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_user_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateUserInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_156) = &input.email {
        object.key("Email").string(var_156.as_str());
    }
    if let Some(var_157) = &input.user_type {
        object.key("UserType").string(var_157.as_str());
    }
    if let Some(var_158) = &input.username {
        object.key("Username").string(var_158.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_voice_connector_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateVoiceConnectorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_159) = &input.aws_region {
        object.key("AwsRegion").string(var_159.as_str());
    }
    if let Some(var_160) = &input.name {
        object.key("Name").string(var_160.as_str());
    }
    if let Some(var_161) = &input.require_encryption {
        object.key("RequireEncryption").boolean(*var_161);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_voice_connector_group_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateVoiceConnectorGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_162) = &input.name {
        object.key("Name").string(var_162.as_str());
    }
    if let Some(var_163) = &input.voice_connector_items {
        let mut array_164 = object.key("VoiceConnectorItems").start_array();
        for item_165 in var_163 {
            {
                #[allow(unused_mut)]
                let mut object_166 = array_164.value().start_object();
                crate::json_ser::serialize_structure_crate_model_voice_connector_item(
                    &mut object_166,
                    item_165,
                )?;
                object_166.finish();
            }
        }
        array_164.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_voice_connector_termination_credentials_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteVoiceConnectorTerminationCredentialsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_167) = &input.usernames {
        let mut array_168 = object.key("Usernames").start_array();
        for item_169 in var_167 {
            {
                array_168.value().string(item_169.as_str());
            }
        }
        array_168.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_disassociate_phone_numbers_from_voice_connector_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DisassociatePhoneNumbersFromVoiceConnectorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_170) = &input.e164_phone_numbers {
        let mut array_171 = object.key("E164PhoneNumbers").start_array();
        for item_172 in var_170 {
            {
                array_171.value().string(item_172.as_str());
            }
        }
        array_171.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_disassociate_phone_numbers_from_voice_connector_group_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DisassociatePhoneNumbersFromVoiceConnectorGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_173) = &input.e164_phone_numbers {
        let mut array_174 = object.key("E164PhoneNumbers").start_array();
        for item_175 in var_173 {
            {
                array_174.value().string(item_175.as_str());
            }
        }
        array_174.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_disassociate_signin_delegate_groups_from_account_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DisassociateSigninDelegateGroupsFromAccountInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_176) = &input.group_names {
        let mut array_177 = object.key("GroupNames").start_array();
        for item_178 in var_176 {
            {
                array_177.value().string(item_178.as_str());
            }
        }
        array_177.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_invite_users_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::InviteUsersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_179) = &input.user_email_list {
        let mut array_180 = object.key("UserEmailList").start_array();
        for item_181 in var_179 {
            {
                array_180.value().string(item_181.as_str());
            }
        }
        array_180.finish();
    }
    if let Some(var_182) = &input.user_type {
        object.key("UserType").string(var_182.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_app_instance_retention_settings_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutAppInstanceRetentionSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_183) = &input.app_instance_retention_settings {
        #[allow(unused_mut)]
        let mut object_184 = object.key("AppInstanceRetentionSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_app_instance_retention_settings(
            &mut object_184,
            var_183,
        )?;
        object_184.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_app_instance_streaming_configurations_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutAppInstanceStreamingConfigurationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_185) = &input.app_instance_streaming_configurations {
        let mut array_186 = object
            .key("AppInstanceStreamingConfigurations")
            .start_array();
        for item_187 in var_185 {
            {
                #[allow(unused_mut)]
                let mut object_188 = array_186.value().start_object();
                crate::json_ser::serialize_structure_crate_model_app_instance_streaming_configuration(&mut object_188, item_187)?;
                object_188.finish();
            }
        }
        array_186.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_events_configuration_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutEventsConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_189) = &input.lambda_function_arn {
        object.key("LambdaFunctionArn").string(var_189.as_str());
    }
    if let Some(var_190) = &input.outbound_events_https_endpoint {
        object
            .key("OutboundEventsHTTPSEndpoint")
            .string(var_190.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_retention_settings_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutRetentionSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_191) = &input.retention_settings {
        #[allow(unused_mut)]
        let mut object_192 = object.key("RetentionSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_retention_settings(
            &mut object_192,
            var_191,
        )?;
        object_192.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_sip_media_application_logging_configuration_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutSipMediaApplicationLoggingConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_193) = &input.sip_media_application_logging_configuration {
        #[allow(unused_mut)]
        let mut object_194 = object
            .key("SipMediaApplicationLoggingConfiguration")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_sip_media_application_logging_configuration(&mut object_194, var_193)?;
        object_194.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_voice_connector_emergency_calling_configuration_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutVoiceConnectorEmergencyCallingConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_195) = &input.emergency_calling_configuration {
        #[allow(unused_mut)]
        let mut object_196 = object.key("EmergencyCallingConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_emergency_calling_configuration(
            &mut object_196,
            var_195,
        )?;
        object_196.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_voice_connector_logging_configuration_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutVoiceConnectorLoggingConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_197) = &input.logging_configuration {
        #[allow(unused_mut)]
        let mut object_198 = object.key("LoggingConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_logging_configuration(
            &mut object_198,
            var_197,
        )?;
        object_198.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_voice_connector_origination_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutVoiceConnectorOriginationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_199) = &input.origination {
        #[allow(unused_mut)]
        let mut object_200 = object.key("Origination").start_object();
        crate::json_ser::serialize_structure_crate_model_origination(&mut object_200, var_199)?;
        object_200.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_voice_connector_proxy_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutVoiceConnectorProxyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_201) = &input.default_session_expiry_minutes {
        object.key("DefaultSessionExpiryMinutes").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_201).into()),
        );
    }
    if let Some(var_202) = &input.disabled {
        object.key("Disabled").boolean(*var_202);
    }
    if let Some(var_203) = &input.fall_back_phone_number {
        object.key("FallBackPhoneNumber").string(var_203.as_str());
    }
    if let Some(var_204) = &input.phone_number_pool_countries {
        let mut array_205 = object.key("PhoneNumberPoolCountries").start_array();
        for item_206 in var_204 {
            {
                array_205.value().string(item_206.as_str());
            }
        }
        array_205.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_voice_connector_streaming_configuration_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutVoiceConnectorStreamingConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_207) = &input.streaming_configuration {
        #[allow(unused_mut)]
        let mut object_208 = object.key("StreamingConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_streaming_configuration(
            &mut object_208,
            var_207,
        )?;
        object_208.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_voice_connector_termination_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutVoiceConnectorTerminationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_209) = &input.termination {
        #[allow(unused_mut)]
        let mut object_210 = object.key("Termination").start_object();
        crate::json_ser::serialize_structure_crate_model_termination(&mut object_210, var_209)?;
        object_210.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_voice_connector_termination_credentials_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutVoiceConnectorTerminationCredentialsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_211) = &input.credentials {
        let mut array_212 = object.key("Credentials").start_array();
        for item_213 in var_211 {
            {
                #[allow(unused_mut)]
                let mut object_214 = array_212.value().start_object();
                crate::json_ser::serialize_structure_crate_model_credential(
                    &mut object_214,
                    item_213,
                )?;
                object_214.finish();
            }
        }
        array_212.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_send_channel_message_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::SendChannelMessageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_215) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_215.as_str());
    }
    if let Some(var_216) = &input.content {
        object.key("Content").string(var_216.as_str());
    }
    if let Some(var_217) = &input.metadata {
        object.key("Metadata").string(var_217.as_str());
    }
    if let Some(var_218) = &input.persistence {
        object.key("Persistence").string(var_218.as_str());
    }
    if let Some(var_219) = &input.r#type {
        object.key("Type").string(var_219.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_start_meeting_transcription_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::StartMeetingTranscriptionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_220) = &input.transcription_configuration {
        #[allow(unused_mut)]
        let mut object_221 = object.key("TranscriptionConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_transcription_configuration(
            &mut object_221,
            var_220,
        )?;
        object_221.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_tag_attendee_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::TagAttendeeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_222) = &input.tags {
        let mut array_223 = object.key("Tags").start_array();
        for item_224 in var_222 {
            {
                #[allow(unused_mut)]
                let mut object_225 = array_223.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_225, item_224)?;
                object_225.finish();
            }
        }
        array_223.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_tag_meeting_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::TagMeetingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_226) = &input.tags {
        let mut array_227 = object.key("Tags").start_array();
        for item_228 in var_226 {
            {
                #[allow(unused_mut)]
                let mut object_229 = array_227.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_229, item_228)?;
                object_229.finish();
            }
        }
        array_227.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_tag_resource_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_230) = &input.resource_arn {
        object.key("ResourceARN").string(var_230.as_str());
    }
    if let Some(var_231) = &input.tags {
        let mut array_232 = object.key("Tags").start_array();
        for item_233 in var_231 {
            {
                #[allow(unused_mut)]
                let mut object_234 = array_232.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_234, item_233)?;
                object_234.finish();
            }
        }
        array_232.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_untag_attendee_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UntagAttendeeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_235) = &input.tag_keys {
        let mut array_236 = object.key("TagKeys").start_array();
        for item_237 in var_235 {
            {
                array_236.value().string(item_237.as_str());
            }
        }
        array_236.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_untag_meeting_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UntagMeetingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_238) = &input.tag_keys {
        let mut array_239 = object.key("TagKeys").start_array();
        for item_240 in var_238 {
            {
                array_239.value().string(item_240.as_str());
            }
        }
        array_239.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_untag_resource_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UntagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_241) = &input.resource_arn {
        object.key("ResourceARN").string(var_241.as_str());
    }
    if let Some(var_242) = &input.tag_keys {
        let mut array_243 = object.key("TagKeys").start_array();
        for item_244 in var_242 {
            {
                array_243.value().string(item_244.as_str());
            }
        }
        array_243.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_account_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateAccountInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_245) = &input.default_license {
        object.key("DefaultLicense").string(var_245.as_str());
    }
    if let Some(var_246) = &input.name {
        object.key("Name").string(var_246.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_account_settings_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateAccountSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_247) = &input.account_settings {
        #[allow(unused_mut)]
        let mut object_248 = object.key("AccountSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_account_settings(
            &mut object_248,
            var_247,
        )?;
        object_248.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_app_instance_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateAppInstanceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_249) = &input.metadata {
        object.key("Metadata").string(var_249.as_str());
    }
    if let Some(var_250) = &input.name {
        object.key("Name").string(var_250.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_app_instance_user_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateAppInstanceUserInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_251) = &input.metadata {
        object.key("Metadata").string(var_251.as_str());
    }
    if let Some(var_252) = &input.name {
        object.key("Name").string(var_252.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_bot_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateBotInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_253) = &input.disabled {
        object.key("Disabled").boolean(*var_253);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_channel_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateChannelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_254) = &input.metadata {
        object.key("Metadata").string(var_254.as_str());
    }
    if let Some(var_255) = &input.mode {
        object.key("Mode").string(var_255.as_str());
    }
    if let Some(var_256) = &input.name {
        object.key("Name").string(var_256.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_channel_message_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateChannelMessageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_257) = &input.content {
        object.key("Content").string(var_257.as_str());
    }
    if let Some(var_258) = &input.metadata {
        object.key("Metadata").string(var_258.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_global_settings_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateGlobalSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_259) = &input.business_calling {
        #[allow(unused_mut)]
        let mut object_260 = object.key("BusinessCalling").start_object();
        crate::json_ser::serialize_structure_crate_model_business_calling_settings(
            &mut object_260,
            var_259,
        )?;
        object_260.finish();
    }
    if let Some(var_261) = &input.voice_connector {
        #[allow(unused_mut)]
        let mut object_262 = object.key("VoiceConnector").start_object();
        crate::json_ser::serialize_structure_crate_model_voice_connector_settings(
            &mut object_262,
            var_261,
        )?;
        object_262.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_phone_number_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdatePhoneNumberInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_263) = &input.calling_name {
        object.key("CallingName").string(var_263.as_str());
    }
    if let Some(var_264) = &input.product_type {
        object.key("ProductType").string(var_264.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_phone_number_settings_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdatePhoneNumberSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_265) = &input.calling_name {
        object.key("CallingName").string(var_265.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_proxy_session_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateProxySessionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_266) = &input.capabilities {
        let mut array_267 = object.key("Capabilities").start_array();
        for item_268 in var_266 {
            {
                array_267.value().string(item_268.as_str());
            }
        }
        array_267.finish();
    }
    if let Some(var_269) = &input.expiry_minutes {
        object.key("ExpiryMinutes").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_269).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_room_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateRoomInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_270) = &input.name {
        object.key("Name").string(var_270.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_room_membership_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateRoomMembershipInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_271) = &input.role {
        object.key("Role").string(var_271.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_sip_media_application_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateSipMediaApplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_272) = &input.endpoints {
        let mut array_273 = object.key("Endpoints").start_array();
        for item_274 in var_272 {
            {
                #[allow(unused_mut)]
                let mut object_275 = array_273.value().start_object();
                crate::json_ser::serialize_structure_crate_model_sip_media_application_endpoint(
                    &mut object_275,
                    item_274,
                )?;
                object_275.finish();
            }
        }
        array_273.finish();
    }
    if let Some(var_276) = &input.name {
        object.key("Name").string(var_276.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_sip_media_application_call_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateSipMediaApplicationCallInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_277) = &input.arguments {
        #[allow(unused_mut)]
        let mut object_278 = object.key("Arguments").start_object();
        for (key_279, value_280) in var_277 {
            {
                object_278.key(key_279.as_str()).string(value_280.as_str());
            }
        }
        object_278.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_sip_rule_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateSipRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_281) = &input.disabled {
        object.key("Disabled").boolean(*var_281);
    }
    if let Some(var_282) = &input.name {
        object.key("Name").string(var_282.as_str());
    }
    if let Some(var_283) = &input.target_applications {
        let mut array_284 = object.key("TargetApplications").start_array();
        for item_285 in var_283 {
            {
                #[allow(unused_mut)]
                let mut object_286 = array_284.value().start_object();
                crate::json_ser::serialize_structure_crate_model_sip_rule_target_application(
                    &mut object_286,
                    item_285,
                )?;
                object_286.finish();
            }
        }
        array_284.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_user_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateUserInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_287) = &input.alexa_for_business_metadata {
        #[allow(unused_mut)]
        let mut object_288 = object.key("AlexaForBusinessMetadata").start_object();
        crate::json_ser::serialize_structure_crate_model_alexa_for_business_metadata(
            &mut object_288,
            var_287,
        )?;
        object_288.finish();
    }
    if let Some(var_289) = &input.license_type {
        object.key("LicenseType").string(var_289.as_str());
    }
    if let Some(var_290) = &input.user_type {
        object.key("UserType").string(var_290.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_user_settings_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateUserSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_291) = &input.user_settings {
        #[allow(unused_mut)]
        let mut object_292 = object.key("UserSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_user_settings(&mut object_292, var_291)?;
        object_292.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_voice_connector_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateVoiceConnectorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_293) = &input.name {
        object.key("Name").string(var_293.as_str());
    }
    if let Some(var_294) = &input.require_encryption {
        object.key("RequireEncryption").boolean(*var_294);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_voice_connector_group_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateVoiceConnectorGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_295) = &input.name {
        object.key("Name").string(var_295.as_str());
    }
    if let Some(var_296) = &input.voice_connector_items {
        let mut array_297 = object.key("VoiceConnectorItems").start_array();
        for item_298 in var_296 {
            {
                #[allow(unused_mut)]
                let mut object_299 = array_297.value().start_object();
                crate::json_ser::serialize_structure_crate_model_voice_connector_item(
                    &mut object_299,
                    item_298,
                )?;
                object_299.finish();
            }
        }
        array_297.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_validate_e911_address_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ValidateE911AddressInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_300) = &input.aws_account_id {
        object.key("AwsAccountId").string(var_300.as_str());
    }
    if let Some(var_301) = &input.city {
        object.key("City").string(var_301.as_str());
    }
    if let Some(var_302) = &input.country {
        object.key("Country").string(var_302.as_str());
    }
    if let Some(var_303) = &input.postal_code {
        object.key("PostalCode").string(var_303.as_str());
    }
    if let Some(var_304) = &input.state {
        object.key("State").string(var_304.as_str());
    }
    if let Some(var_305) = &input.street_info {
        object.key("StreetInfo").string(var_305.as_str());
    }
    if let Some(var_306) = &input.street_number {
        object.key("StreetNumber").string(var_306.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_signin_delegate_group(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::SigninDelegateGroup,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_307) = &input.group_name {
        object.key("GroupName").string(var_307.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_create_attendee_request_item(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::CreateAttendeeRequestItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_308) = &input.external_user_id {
        object.key("ExternalUserId").string(var_308.as_str());
    }
    if let Some(var_309) = &input.tags {
        let mut array_310 = object.key("Tags").start_array();
        for item_311 in var_309 {
            {
                #[allow(unused_mut)]
                let mut object_312 = array_310.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_312, item_311)?;
                object_312.finish();
            }
        }
        array_310.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_membership_item(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MembershipItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_313) = &input.member_id {
        object.key("MemberId").string(var_313.as_str());
    }
    if let Some(var_314) = &input.role {
        object.key("Role").string(var_314.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_update_phone_number_request_item(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::UpdatePhoneNumberRequestItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_315) = &input.phone_number_id {
        object.key("PhoneNumberId").string(var_315.as_str());
    }
    if let Some(var_316) = &input.product_type {
        object.key("ProductType").string(var_316.as_str());
    }
    if let Some(var_317) = &input.calling_name {
        object.key("CallingName").string(var_317.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_update_user_request_item(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::UpdateUserRequestItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_318) = &input.user_id {
        object.key("UserId").string(var_318.as_str());
    }
    if let Some(var_319) = &input.license_type {
        object.key("LicenseType").string(var_319.as_str());
    }
    if let Some(var_320) = &input.user_type {
        object.key("UserType").string(var_320.as_str());
    }
    if let Some(var_321) = &input.alexa_for_business_metadata {
        #[allow(unused_mut)]
        let mut object_322 = object.key("AlexaForBusinessMetadata").start_object();
        crate::json_ser::serialize_structure_crate_model_alexa_for_business_metadata(
            &mut object_322,
            var_321,
        )?;
        object_322.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_tag(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_323) = &input.key {
        object.key("Key").string(var_323.as_str());
    }
    if let Some(var_324) = &input.value {
        object.key("Value").string(var_324.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_chime_sdk_meeting_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ChimeSdkMeetingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_325) = &input.source_configuration {
        #[allow(unused_mut)]
        let mut object_326 = object.key("SourceConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_source_configuration(
            &mut object_326,
            var_325,
        )?;
        object_326.finish();
    }
    if let Some(var_327) = &input.artifacts_configuration {
        #[allow(unused_mut)]
        let mut object_328 = object.key("ArtifactsConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_artifacts_configuration(
            &mut object_328,
            var_327,
        )?;
        object_328.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_meeting_notification_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MeetingNotificationConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_329) = &input.sns_topic_arn {
        object.key("SnsTopicArn").string(var_329.as_str());
    }
    if let Some(var_330) = &input.sqs_queue_arn {
        object.key("SqsQueueArn").string(var_330.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_geo_match_params(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GeoMatchParams,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_331) = &input.country {
        object.key("Country").string(var_331.as_str());
    }
    if let Some(var_332) = &input.area_code {
        object.key("AreaCode").string(var_332.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_sip_media_application_endpoint(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::SipMediaApplicationEndpoint,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_333) = &input.lambda_arn {
        object.key("LambdaArn").string(var_333.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_sip_rule_target_application(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::SipRuleTargetApplication,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_334) = &input.sip_media_application_id {
        object.key("SipMediaApplicationId").string(var_334.as_str());
    }
    if let Some(var_335) = &input.priority {
        object.key("Priority").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_335).into()),
        );
    }
    if let Some(var_336) = &input.aws_region {
        object.key("AwsRegion").string(var_336.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_voice_connector_item(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VoiceConnectorItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_337) = &input.voice_connector_id {
        object.key("VoiceConnectorId").string(var_337.as_str());
    }
    if let Some(var_338) = &input.priority {
        object.key("Priority").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_338).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_app_instance_retention_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AppInstanceRetentionSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_339) = &input.channel_retention_settings {
        #[allow(unused_mut)]
        let mut object_340 = object.key("ChannelRetentionSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_channel_retention_settings(
            &mut object_340,
            var_339,
        )?;
        object_340.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_app_instance_streaming_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AppInstanceStreamingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_341) = &input.app_instance_data_type {
        object.key("AppInstanceDataType").string(var_341.as_str());
    }
    if let Some(var_342) = &input.resource_arn {
        object.key("ResourceArn").string(var_342.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_retention_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::RetentionSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_343) = &input.room_retention_settings {
        #[allow(unused_mut)]
        let mut object_344 = object.key("RoomRetentionSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_room_retention_settings(
            &mut object_344,
            var_343,
        )?;
        object_344.finish();
    }
    if let Some(var_345) = &input.conversation_retention_settings {
        #[allow(unused_mut)]
        let mut object_346 = object.key("ConversationRetentionSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_conversation_retention_settings(
            &mut object_346,
            var_345,
        )?;
        object_346.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_sip_media_application_logging_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::SipMediaApplicationLoggingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_347) = &input.enable_sip_media_application_message_logs {
        object
            .key("EnableSipMediaApplicationMessageLogs")
            .boolean(*var_347);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_emergency_calling_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::EmergencyCallingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_348) = &input.dnis {
        let mut array_349 = object.key("DNIS").start_array();
        for item_350 in var_348 {
            {
                #[allow(unused_mut)]
                let mut object_351 = array_349.value().start_object();
                crate::json_ser::serialize_structure_crate_model_dnis_emergency_calling_configuration(&mut object_351, item_350)?;
                object_351.finish();
            }
        }
        array_349.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_logging_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::LoggingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_352) = &input.enable_sip_logs {
        object.key("EnableSIPLogs").boolean(*var_352);
    }
    if let Some(var_353) = &input.enable_media_metric_logs {
        object.key("EnableMediaMetricLogs").boolean(*var_353);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_origination(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Origination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_354) = &input.routes {
        let mut array_355 = object.key("Routes").start_array();
        for item_356 in var_354 {
            {
                #[allow(unused_mut)]
                let mut object_357 = array_355.value().start_object();
                crate::json_ser::serialize_structure_crate_model_origination_route(
                    &mut object_357,
                    item_356,
                )?;
                object_357.finish();
            }
        }
        array_355.finish();
    }
    if let Some(var_358) = &input.disabled {
        object.key("Disabled").boolean(*var_358);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_streaming_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::StreamingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_359) = &input.data_retention_in_hours {
        object.key("DataRetentionInHours").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_359).into()),
        );
    }
    if let Some(var_360) = &input.disabled {
        object.key("Disabled").boolean(*var_360);
    }
    if let Some(var_361) = &input.streaming_notification_targets {
        let mut array_362 = object.key("StreamingNotificationTargets").start_array();
        for item_363 in var_361 {
            {
                #[allow(unused_mut)]
                let mut object_364 = array_362.value().start_object();
                crate::json_ser::serialize_structure_crate_model_streaming_notification_target(
                    &mut object_364,
                    item_363,
                )?;
                object_364.finish();
            }
        }
        array_362.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_termination(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Termination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_365) = &input.cps_limit {
        object.key("CpsLimit").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_365).into()),
        );
    }
    if let Some(var_366) = &input.default_phone_number {
        object.key("DefaultPhoneNumber").string(var_366.as_str());
    }
    if let Some(var_367) = &input.calling_regions {
        let mut array_368 = object.key("CallingRegions").start_array();
        for item_369 in var_367 {
            {
                array_368.value().string(item_369.as_str());
            }
        }
        array_368.finish();
    }
    if let Some(var_370) = &input.cidr_allowed_list {
        let mut array_371 = object.key("CidrAllowedList").start_array();
        for item_372 in var_370 {
            {
                array_371.value().string(item_372.as_str());
            }
        }
        array_371.finish();
    }
    if let Some(var_373) = &input.disabled {
        object.key("Disabled").boolean(*var_373);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_credential(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Credential,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_374) = &input.username {
        object.key("Username").string(var_374.as_str());
    }
    if let Some(var_375) = &input.password {
        object.key("Password").string(var_375.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_transcription_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TranscriptionConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_376) = &input.engine_transcribe_settings {
        #[allow(unused_mut)]
        let mut object_377 = object.key("EngineTranscribeSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_engine_transcribe_settings(
            &mut object_377,
            var_376,
        )?;
        object_377.finish();
    }
    if let Some(var_378) = &input.engine_transcribe_medical_settings {
        #[allow(unused_mut)]
        let mut object_379 = object.key("EngineTranscribeMedicalSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_engine_transcribe_medical_settings(
            &mut object_379,
            var_378,
        )?;
        object_379.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_account_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AccountSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_380) = &input.disable_remote_control {
        object.key("DisableRemoteControl").boolean(*var_380);
    }
    if let Some(var_381) = &input.enable_dial_out {
        object.key("EnableDialOut").boolean(*var_381);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_business_calling_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::BusinessCallingSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_382) = &input.cdr_bucket {
        object.key("CdrBucket").string(var_382.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_voice_connector_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VoiceConnectorSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_383) = &input.cdr_bucket {
        object.key("CdrBucket").string(var_383.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_alexa_for_business_metadata(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AlexaForBusinessMetadata,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_384) = &input.is_alexa_for_business_enabled {
        object.key("IsAlexaForBusinessEnabled").boolean(*var_384);
    }
    if let Some(var_385) = &input.alexa_for_business_room_arn {
        object
            .key("AlexaForBusinessRoomArn")
            .string(var_385.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_user_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::UserSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_386) = &input.telephony {
        #[allow(unused_mut)]
        let mut object_387 = object.key("Telephony").start_object();
        crate::json_ser::serialize_structure_crate_model_telephony_settings(
            &mut object_387,
            var_386,
        )?;
        object_387.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_source_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::SourceConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_388) = &input.selected_video_streams {
        #[allow(unused_mut)]
        let mut object_389 = object.key("SelectedVideoStreams").start_object();
        crate::json_ser::serialize_structure_crate_model_selected_video_streams(
            &mut object_389,
            var_388,
        )?;
        object_389.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_artifacts_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ArtifactsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_390) = &input.audio {
        #[allow(unused_mut)]
        let mut object_391 = object.key("Audio").start_object();
        crate::json_ser::serialize_structure_crate_model_audio_artifacts_configuration(
            &mut object_391,
            var_390,
        )?;
        object_391.finish();
    }
    if let Some(var_392) = &input.video {
        #[allow(unused_mut)]
        let mut object_393 = object.key("Video").start_object();
        crate::json_ser::serialize_structure_crate_model_video_artifacts_configuration(
            &mut object_393,
            var_392,
        )?;
        object_393.finish();
    }
    if let Some(var_394) = &input.content {
        #[allow(unused_mut)]
        let mut object_395 = object.key("Content").start_object();
        crate::json_ser::serialize_structure_crate_model_content_artifacts_configuration(
            &mut object_395,
            var_394,
        )?;
        object_395.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_channel_retention_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ChannelRetentionSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_396) = &input.retention_days {
        object.key("RetentionDays").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_396).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_room_retention_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::RoomRetentionSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_397) = &input.retention_days {
        object.key("RetentionDays").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_397).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_conversation_retention_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ConversationRetentionSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_398) = &input.retention_days {
        object.key("RetentionDays").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_398).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_dnis_emergency_calling_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DnisEmergencyCallingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_399) = &input.emergency_phone_number {
        object.key("EmergencyPhoneNumber").string(var_399.as_str());
    }
    if let Some(var_400) = &input.test_phone_number {
        object.key("TestPhoneNumber").string(var_400.as_str());
    }
    if let Some(var_401) = &input.calling_country {
        object.key("CallingCountry").string(var_401.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_origination_route(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::OriginationRoute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_402) = &input.host {
        object.key("Host").string(var_402.as_str());
    }
    if let Some(var_403) = &input.port {
        object.key("Port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_403).into()),
        );
    }
    if let Some(var_404) = &input.protocol {
        object.key("Protocol").string(var_404.as_str());
    }
    if let Some(var_405) = &input.priority {
        object.key("Priority").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_405).into()),
        );
    }
    if let Some(var_406) = &input.weight {
        object.key("Weight").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_406).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_streaming_notification_target(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::StreamingNotificationTarget,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_407) = &input.notification_target {
        object.key("NotificationTarget").string(var_407.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_engine_transcribe_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::EngineTranscribeSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_408) = &input.language_code {
        object.key("LanguageCode").string(var_408.as_str());
    }
    if let Some(var_409) = &input.vocabulary_filter_method {
        object
            .key("VocabularyFilterMethod")
            .string(var_409.as_str());
    }
    if let Some(var_410) = &input.vocabulary_filter_name {
        object.key("VocabularyFilterName").string(var_410.as_str());
    }
    if let Some(var_411) = &input.vocabulary_name {
        object.key("VocabularyName").string(var_411.as_str());
    }
    if let Some(var_412) = &input.region {
        object.key("Region").string(var_412.as_str());
    }
    if let Some(var_413) = &input.enable_partial_results_stabilization {
        object
            .key("EnablePartialResultsStabilization")
            .boolean(*var_413);
    }
    if let Some(var_414) = &input.partial_results_stability {
        object
            .key("PartialResultsStability")
            .string(var_414.as_str());
    }
    if let Some(var_415) = &input.content_identification_type {
        object
            .key("ContentIdentificationType")
            .string(var_415.as_str());
    }
    if let Some(var_416) = &input.content_redaction_type {
        object.key("ContentRedactionType").string(var_416.as_str());
    }
    if let Some(var_417) = &input.pii_entity_types {
        object.key("PiiEntityTypes").string(var_417.as_str());
    }
    if let Some(var_418) = &input.language_model_name {
        object.key("LanguageModelName").string(var_418.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_engine_transcribe_medical_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::EngineTranscribeMedicalSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_419) = &input.language_code {
        object.key("LanguageCode").string(var_419.as_str());
    }
    if let Some(var_420) = &input.specialty {
        object.key("Specialty").string(var_420.as_str());
    }
    if let Some(var_421) = &input.r#type {
        object.key("Type").string(var_421.as_str());
    }
    if let Some(var_422) = &input.vocabulary_name {
        object.key("VocabularyName").string(var_422.as_str());
    }
    if let Some(var_423) = &input.region {
        object.key("Region").string(var_423.as_str());
    }
    if let Some(var_424) = &input.content_identification_type {
        object
            .key("ContentIdentificationType")
            .string(var_424.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_telephony_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TelephonySettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_425) = &input.inbound_calling {
        object.key("InboundCalling").boolean(*var_425);
    }
    if let Some(var_426) = &input.outbound_calling {
        object.key("OutboundCalling").boolean(*var_426);
    }
    if let Some(var_427) = &input.sms {
        object.key("SMS").boolean(*var_427);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_selected_video_streams(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::SelectedVideoStreams,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_428) = &input.attendee_ids {
        let mut array_429 = object.key("AttendeeIds").start_array();
        for item_430 in var_428 {
            {
                array_429.value().string(item_430.as_str());
            }
        }
        array_429.finish();
    }
    if let Some(var_431) = &input.external_user_ids {
        let mut array_432 = object.key("ExternalUserIds").start_array();
        for item_433 in var_431 {
            {
                array_432.value().string(item_433.as_str());
            }
        }
        array_432.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_audio_artifacts_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AudioArtifactsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_434) = &input.mux_type {
        object.key("MuxType").string(var_434.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_video_artifacts_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VideoArtifactsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_435) = &input.state {
        object.key("State").string(var_435.as_str());
    }
    if let Some(var_436) = &input.mux_type {
        object.key("MuxType").string(var_436.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_content_artifacts_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ContentArtifactsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_437) = &input.state {
        object.key("State").string(var_437.as_str());
    }
    if let Some(var_438) = &input.mux_type {
        object.key("MuxType").string(var_438.as_str());
    }
    Ok(())
}