// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
pub fn serialize_structure_crate_input_approve_skill_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ApproveSkillInput,
) {
    if let Some(var_1) = &input.skill_id {
        object.key("SkillId").string(var_1);
    }
}

pub fn serialize_structure_crate_input_associate_contact_with_address_book_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::AssociateContactWithAddressBookInput,
) {
    if let Some(var_2) = &input.contact_arn {
        object.key("ContactArn").string(var_2);
    }
    if let Some(var_3) = &input.address_book_arn {
        object.key("AddressBookArn").string(var_3);
    }
}

pub fn serialize_structure_crate_input_associate_device_with_network_profile_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::AssociateDeviceWithNetworkProfileInput,
) {
    if let Some(var_4) = &input.device_arn {
        object.key("DeviceArn").string(var_4);
    }
    if let Some(var_5) = &input.network_profile_arn {
        object.key("NetworkProfileArn").string(var_5);
    }
}

pub fn serialize_structure_crate_input_associate_device_with_room_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::AssociateDeviceWithRoomInput,
) {
    if let Some(var_6) = &input.device_arn {
        object.key("DeviceArn").string(var_6);
    }
    if let Some(var_7) = &input.room_arn {
        object.key("RoomArn").string(var_7);
    }
}

pub fn serialize_structure_crate_input_associate_skill_group_with_room_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::AssociateSkillGroupWithRoomInput,
) {
    if let Some(var_8) = &input.skill_group_arn {
        object.key("SkillGroupArn").string(var_8);
    }
    if let Some(var_9) = &input.room_arn {
        object.key("RoomArn").string(var_9);
    }
}

pub fn serialize_structure_crate_input_associate_skill_with_skill_group_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::AssociateSkillWithSkillGroupInput,
) {
    if let Some(var_10) = &input.skill_group_arn {
        object.key("SkillGroupArn").string(var_10);
    }
    if let Some(var_11) = &input.skill_id {
        object.key("SkillId").string(var_11);
    }
}

pub fn serialize_structure_crate_input_associate_skill_with_users_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::AssociateSkillWithUsersInput,
) {
    if let Some(var_12) = &input.skill_id {
        object.key("SkillId").string(var_12);
    }
}

pub fn serialize_structure_crate_input_create_address_book_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateAddressBookInput,
) {
    if let Some(var_13) = &input.name {
        object.key("Name").string(var_13);
    }
    if let Some(var_14) = &input.description {
        object.key("Description").string(var_14);
    }
    if let Some(var_15) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_15);
    }
    if let Some(var_16) = &input.tags {
        let mut array_17 = object.key("Tags").start_array();
        for item_18 in var_16 {
            {
                let mut object_19 = array_17.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_19, item_18);
                object_19.finish();
            }
        }
        array_17.finish();
    }
}

pub fn serialize_structure_crate_input_create_business_report_schedule_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateBusinessReportScheduleInput,
) {
    if let Some(var_20) = &input.schedule_name {
        object.key("ScheduleName").string(var_20);
    }
    if let Some(var_21) = &input.s3_bucket_name {
        object.key("S3BucketName").string(var_21);
    }
    if let Some(var_22) = &input.s3_key_prefix {
        object.key("S3KeyPrefix").string(var_22);
    }
    if let Some(var_23) = &input.format {
        object.key("Format").string(var_23.as_str());
    }
    if let Some(var_24) = &input.content_range {
        let mut object_25 = object.key("ContentRange").start_object();
        crate::json_ser::serialize_structure_crate_model_business_report_content_range(
            &mut object_25,
            var_24,
        );
        object_25.finish();
    }
    if let Some(var_26) = &input.recurrence {
        let mut object_27 = object.key("Recurrence").start_object();
        crate::json_ser::serialize_structure_crate_model_business_report_recurrence(
            &mut object_27,
            var_26,
        );
        object_27.finish();
    }
    if let Some(var_28) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_28);
    }
    if let Some(var_29) = &input.tags {
        let mut array_30 = object.key("Tags").start_array();
        for item_31 in var_29 {
            {
                let mut object_32 = array_30.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_32, item_31);
                object_32.finish();
            }
        }
        array_30.finish();
    }
}

pub fn serialize_structure_crate_input_create_conference_provider_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateConferenceProviderInput,
) {
    if let Some(var_33) = &input.conference_provider_name {
        object.key("ConferenceProviderName").string(var_33);
    }
    if let Some(var_34) = &input.conference_provider_type {
        object.key("ConferenceProviderType").string(var_34.as_str());
    }
    if let Some(var_35) = &input.ip_dial_in {
        let mut object_36 = object.key("IPDialIn").start_object();
        crate::json_ser::serialize_structure_crate_model_ip_dial_in(&mut object_36, var_35);
        object_36.finish();
    }
    if let Some(var_37) = &input.pstn_dial_in {
        let mut object_38 = object.key("PSTNDialIn").start_object();
        crate::json_ser::serialize_structure_crate_model_pstn_dial_in(&mut object_38, var_37);
        object_38.finish();
    }
    if let Some(var_39) = &input.meeting_setting {
        let mut object_40 = object.key("MeetingSetting").start_object();
        crate::json_ser::serialize_structure_crate_model_meeting_setting(&mut object_40, var_39);
        object_40.finish();
    }
    if let Some(var_41) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_41);
    }
    if let Some(var_42) = &input.tags {
        let mut array_43 = object.key("Tags").start_array();
        for item_44 in var_42 {
            {
                let mut object_45 = array_43.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_45, item_44);
                object_45.finish();
            }
        }
        array_43.finish();
    }
}

pub fn serialize_structure_crate_input_create_contact_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateContactInput,
) {
    if let Some(var_46) = &input.display_name {
        object.key("DisplayName").string(var_46);
    }
    if let Some(var_47) = &input.first_name {
        object.key("FirstName").string(var_47);
    }
    if let Some(var_48) = &input.last_name {
        object.key("LastName").string(var_48);
    }
    if let Some(var_49) = &input.phone_number {
        object.key("PhoneNumber").string(var_49);
    }
    if let Some(var_50) = &input.phone_numbers {
        let mut array_51 = object.key("PhoneNumbers").start_array();
        for item_52 in var_50 {
            {
                let mut object_53 = array_51.value().start_object();
                crate::json_ser::serialize_structure_crate_model_phone_number(
                    &mut object_53,
                    item_52,
                );
                object_53.finish();
            }
        }
        array_51.finish();
    }
    if let Some(var_54) = &input.sip_addresses {
        let mut array_55 = object.key("SipAddresses").start_array();
        for item_56 in var_54 {
            {
                let mut object_57 = array_55.value().start_object();
                crate::json_ser::serialize_structure_crate_model_sip_address(
                    &mut object_57,
                    item_56,
                );
                object_57.finish();
            }
        }
        array_55.finish();
    }
    if let Some(var_58) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_58);
    }
    if let Some(var_59) = &input.tags {
        let mut array_60 = object.key("Tags").start_array();
        for item_61 in var_59 {
            {
                let mut object_62 = array_60.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_62, item_61);
                object_62.finish();
            }
        }
        array_60.finish();
    }
}

pub fn serialize_structure_crate_input_create_gateway_group_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateGatewayGroupInput,
) {
    if let Some(var_63) = &input.name {
        object.key("Name").string(var_63);
    }
    if let Some(var_64) = &input.description {
        object.key("Description").string(var_64);
    }
    if let Some(var_65) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_65);
    }
    if let Some(var_66) = &input.tags {
        let mut array_67 = object.key("Tags").start_array();
        for item_68 in var_66 {
            {
                let mut object_69 = array_67.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_69, item_68);
                object_69.finish();
            }
        }
        array_67.finish();
    }
}

pub fn serialize_structure_crate_input_create_network_profile_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateNetworkProfileInput,
) {
    if let Some(var_70) = &input.network_profile_name {
        object.key("NetworkProfileName").string(var_70);
    }
    if let Some(var_71) = &input.description {
        object.key("Description").string(var_71);
    }
    if let Some(var_72) = &input.ssid {
        object.key("Ssid").string(var_72);
    }
    if let Some(var_73) = &input.security_type {
        object.key("SecurityType").string(var_73.as_str());
    }
    if let Some(var_74) = &input.eap_method {
        object.key("EapMethod").string(var_74.as_str());
    }
    if let Some(var_75) = &input.current_password {
        object.key("CurrentPassword").string(var_75);
    }
    if let Some(var_76) = &input.next_password {
        object.key("NextPassword").string(var_76);
    }
    if let Some(var_77) = &input.certificate_authority_arn {
        object.key("CertificateAuthorityArn").string(var_77);
    }
    if let Some(var_78) = &input.trust_anchors {
        let mut array_79 = object.key("TrustAnchors").start_array();
        for item_80 in var_78 {
            {
                array_79.value().string(item_80);
            }
        }
        array_79.finish();
    }
    if let Some(var_81) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_81);
    }
    if let Some(var_82) = &input.tags {
        let mut array_83 = object.key("Tags").start_array();
        for item_84 in var_82 {
            {
                let mut object_85 = array_83.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_85, item_84);
                object_85.finish();
            }
        }
        array_83.finish();
    }
}

pub fn serialize_structure_crate_input_create_profile_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateProfileInput,
) {
    if let Some(var_86) = &input.profile_name {
        object.key("ProfileName").string(var_86);
    }
    if let Some(var_87) = &input.timezone {
        object.key("Timezone").string(var_87);
    }
    if let Some(var_88) = &input.address {
        object.key("Address").string(var_88);
    }
    if let Some(var_89) = &input.distance_unit {
        object.key("DistanceUnit").string(var_89.as_str());
    }
    if let Some(var_90) = &input.temperature_unit {
        object.key("TemperatureUnit").string(var_90.as_str());
    }
    if let Some(var_91) = &input.wake_word {
        object.key("WakeWord").string(var_91.as_str());
    }
    if let Some(var_92) = &input.locale {
        object.key("Locale").string(var_92);
    }
    if let Some(var_93) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_93);
    }
    if let Some(var_94) = &input.setup_mode_disabled {
        object.key("SetupModeDisabled").boolean(*var_94);
    }
    if let Some(var_95) = &input.max_volume_limit {
        object.key("MaxVolumeLimit").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_95).into()),
        );
    }
    if let Some(var_96) = &input.pstn_enabled {
        object.key("PSTNEnabled").boolean(*var_96);
    }
    if let Some(var_97) = &input.data_retention_opt_in {
        object.key("DataRetentionOptIn").boolean(*var_97);
    }
    if let Some(var_98) = &input.meeting_room_configuration {
        let mut object_99 = object.key("MeetingRoomConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_create_meeting_room_configuration(
            &mut object_99,
            var_98,
        );
        object_99.finish();
    }
    if let Some(var_100) = &input.tags {
        let mut array_101 = object.key("Tags").start_array();
        for item_102 in var_100 {
            {
                let mut object_103 = array_101.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_103, item_102);
                object_103.finish();
            }
        }
        array_101.finish();
    }
}

pub fn serialize_structure_crate_input_create_room_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateRoomInput,
) {
    if let Some(var_104) = &input.room_name {
        object.key("RoomName").string(var_104);
    }
    if let Some(var_105) = &input.description {
        object.key("Description").string(var_105);
    }
    if let Some(var_106) = &input.profile_arn {
        object.key("ProfileArn").string(var_106);
    }
    if let Some(var_107) = &input.provider_calendar_id {
        object.key("ProviderCalendarId").string(var_107);
    }
    if let Some(var_108) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_108);
    }
    if let Some(var_109) = &input.tags {
        let mut array_110 = object.key("Tags").start_array();
        for item_111 in var_109 {
            {
                let mut object_112 = array_110.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_112, item_111);
                object_112.finish();
            }
        }
        array_110.finish();
    }
}

pub fn serialize_structure_crate_input_create_skill_group_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateSkillGroupInput,
) {
    if let Some(var_113) = &input.skill_group_name {
        object.key("SkillGroupName").string(var_113);
    }
    if let Some(var_114) = &input.description {
        object.key("Description").string(var_114);
    }
    if let Some(var_115) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_115);
    }
    if let Some(var_116) = &input.tags {
        let mut array_117 = object.key("Tags").start_array();
        for item_118 in var_116 {
            {
                let mut object_119 = array_117.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_119, item_118);
                object_119.finish();
            }
        }
        array_117.finish();
    }
}

pub fn serialize_structure_crate_input_create_user_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateUserInput,
) {
    if let Some(var_120) = &input.user_id {
        object.key("UserId").string(var_120);
    }
    if let Some(var_121) = &input.first_name {
        object.key("FirstName").string(var_121);
    }
    if let Some(var_122) = &input.last_name {
        object.key("LastName").string(var_122);
    }
    if let Some(var_123) = &input.email {
        object.key("Email").string(var_123);
    }
    if let Some(var_124) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_124);
    }
    if let Some(var_125) = &input.tags {
        let mut array_126 = object.key("Tags").start_array();
        for item_127 in var_125 {
            {
                let mut object_128 = array_126.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_128, item_127);
                object_128.finish();
            }
        }
        array_126.finish();
    }
}

pub fn serialize_structure_crate_input_delete_address_book_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteAddressBookInput,
) {
    if let Some(var_129) = &input.address_book_arn {
        object.key("AddressBookArn").string(var_129);
    }
}

pub fn serialize_structure_crate_input_delete_business_report_schedule_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteBusinessReportScheduleInput,
) {
    if let Some(var_130) = &input.schedule_arn {
        object.key("ScheduleArn").string(var_130);
    }
}

pub fn serialize_structure_crate_input_delete_conference_provider_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteConferenceProviderInput,
) {
    if let Some(var_131) = &input.conference_provider_arn {
        object.key("ConferenceProviderArn").string(var_131);
    }
}

pub fn serialize_structure_crate_input_delete_contact_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteContactInput,
) {
    if let Some(var_132) = &input.contact_arn {
        object.key("ContactArn").string(var_132);
    }
}

pub fn serialize_structure_crate_input_delete_device_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteDeviceInput,
) {
    if let Some(var_133) = &input.device_arn {
        object.key("DeviceArn").string(var_133);
    }
}

pub fn serialize_structure_crate_input_delete_device_usage_data_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteDeviceUsageDataInput,
) {
    if let Some(var_134) = &input.device_arn {
        object.key("DeviceArn").string(var_134);
    }
    if let Some(var_135) = &input.device_usage_type {
        object.key("DeviceUsageType").string(var_135.as_str());
    }
}

pub fn serialize_structure_crate_input_delete_gateway_group_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteGatewayGroupInput,
) {
    if let Some(var_136) = &input.gateway_group_arn {
        object.key("GatewayGroupArn").string(var_136);
    }
}

pub fn serialize_structure_crate_input_delete_network_profile_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteNetworkProfileInput,
) {
    if let Some(var_137) = &input.network_profile_arn {
        object.key("NetworkProfileArn").string(var_137);
    }
}

pub fn serialize_structure_crate_input_delete_profile_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteProfileInput,
) {
    if let Some(var_138) = &input.profile_arn {
        object.key("ProfileArn").string(var_138);
    }
}

pub fn serialize_structure_crate_input_delete_room_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteRoomInput,
) {
    if let Some(var_139) = &input.room_arn {
        object.key("RoomArn").string(var_139);
    }
}

pub fn serialize_structure_crate_input_delete_room_skill_parameter_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteRoomSkillParameterInput,
) {
    if let Some(var_140) = &input.room_arn {
        object.key("RoomArn").string(var_140);
    }
    if let Some(var_141) = &input.skill_id {
        object.key("SkillId").string(var_141);
    }
    if let Some(var_142) = &input.parameter_key {
        object.key("ParameterKey").string(var_142);
    }
}

pub fn serialize_structure_crate_input_delete_skill_authorization_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteSkillAuthorizationInput,
) {
    if let Some(var_143) = &input.skill_id {
        object.key("SkillId").string(var_143);
    }
    if let Some(var_144) = &input.room_arn {
        object.key("RoomArn").string(var_144);
    }
}

pub fn serialize_structure_crate_input_delete_skill_group_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteSkillGroupInput,
) {
    if let Some(var_145) = &input.skill_group_arn {
        object.key("SkillGroupArn").string(var_145);
    }
}

pub fn serialize_structure_crate_input_delete_user_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteUserInput,
) {
    if let Some(var_146) = &input.user_arn {
        object.key("UserArn").string(var_146);
    }
    if let Some(var_147) = &input.enrollment_id {
        object.key("EnrollmentId").string(var_147);
    }
}

pub fn serialize_structure_crate_input_disassociate_contact_from_address_book_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DisassociateContactFromAddressBookInput,
) {
    if let Some(var_148) = &input.contact_arn {
        object.key("ContactArn").string(var_148);
    }
    if let Some(var_149) = &input.address_book_arn {
        object.key("AddressBookArn").string(var_149);
    }
}

pub fn serialize_structure_crate_input_disassociate_device_from_room_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DisassociateDeviceFromRoomInput,
) {
    if let Some(var_150) = &input.device_arn {
        object.key("DeviceArn").string(var_150);
    }
}

pub fn serialize_structure_crate_input_disassociate_skill_from_skill_group_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DisassociateSkillFromSkillGroupInput,
) {
    if let Some(var_151) = &input.skill_group_arn {
        object.key("SkillGroupArn").string(var_151);
    }
    if let Some(var_152) = &input.skill_id {
        object.key("SkillId").string(var_152);
    }
}

pub fn serialize_structure_crate_input_disassociate_skill_from_users_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DisassociateSkillFromUsersInput,
) {
    if let Some(var_153) = &input.skill_id {
        object.key("SkillId").string(var_153);
    }
}

pub fn serialize_structure_crate_input_disassociate_skill_group_from_room_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DisassociateSkillGroupFromRoomInput,
) {
    if let Some(var_154) = &input.skill_group_arn {
        object.key("SkillGroupArn").string(var_154);
    }
    if let Some(var_155) = &input.room_arn {
        object.key("RoomArn").string(var_155);
    }
}

pub fn serialize_structure_crate_input_forget_smart_home_appliances_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ForgetSmartHomeAppliancesInput,
) {
    if let Some(var_156) = &input.room_arn {
        object.key("RoomArn").string(var_156);
    }
}

pub fn serialize_structure_crate_input_get_address_book_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetAddressBookInput,
) {
    if let Some(var_157) = &input.address_book_arn {
        object.key("AddressBookArn").string(var_157);
    }
}

pub fn serialize_structure_crate_input_get_conference_provider_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetConferenceProviderInput,
) {
    if let Some(var_158) = &input.conference_provider_arn {
        object.key("ConferenceProviderArn").string(var_158);
    }
}

pub fn serialize_structure_crate_input_get_contact_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetContactInput,
) {
    if let Some(var_159) = &input.contact_arn {
        object.key("ContactArn").string(var_159);
    }
}

pub fn serialize_structure_crate_input_get_device_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetDeviceInput,
) {
    if let Some(var_160) = &input.device_arn {
        object.key("DeviceArn").string(var_160);
    }
}

pub fn serialize_structure_crate_input_get_gateway_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetGatewayInput,
) {
    if let Some(var_161) = &input.gateway_arn {
        object.key("GatewayArn").string(var_161);
    }
}

pub fn serialize_structure_crate_input_get_gateway_group_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetGatewayGroupInput,
) {
    if let Some(var_162) = &input.gateway_group_arn {
        object.key("GatewayGroupArn").string(var_162);
    }
}

pub fn serialize_structure_crate_input_get_network_profile_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetNetworkProfileInput,
) {
    if let Some(var_163) = &input.network_profile_arn {
        object.key("NetworkProfileArn").string(var_163);
    }
}

pub fn serialize_structure_crate_input_get_profile_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetProfileInput,
) {
    if let Some(var_164) = &input.profile_arn {
        object.key("ProfileArn").string(var_164);
    }
}

pub fn serialize_structure_crate_input_get_room_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetRoomInput,
) {
    if let Some(var_165) = &input.room_arn {
        object.key("RoomArn").string(var_165);
    }
}

pub fn serialize_structure_crate_input_get_room_skill_parameter_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetRoomSkillParameterInput,
) {
    if let Some(var_166) = &input.room_arn {
        object.key("RoomArn").string(var_166);
    }
    if let Some(var_167) = &input.skill_id {
        object.key("SkillId").string(var_167);
    }
    if let Some(var_168) = &input.parameter_key {
        object.key("ParameterKey").string(var_168);
    }
}

pub fn serialize_structure_crate_input_get_skill_group_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetSkillGroupInput,
) {
    if let Some(var_169) = &input.skill_group_arn {
        object.key("SkillGroupArn").string(var_169);
    }
}

pub fn serialize_structure_crate_input_list_business_report_schedules_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListBusinessReportSchedulesInput,
) {
    if let Some(var_170) = &input.next_token {
        object.key("NextToken").string(var_170);
    }
    if let Some(var_171) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_171).into()),
        );
    }
}

pub fn serialize_structure_crate_input_list_conference_providers_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListConferenceProvidersInput,
) {
    if let Some(var_172) = &input.next_token {
        object.key("NextToken").string(var_172);
    }
    if let Some(var_173) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_173).into()),
        );
    }
}

pub fn serialize_structure_crate_input_list_device_events_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListDeviceEventsInput,
) {
    if let Some(var_174) = &input.device_arn {
        object.key("DeviceArn").string(var_174);
    }
    if let Some(var_175) = &input.event_type {
        object.key("EventType").string(var_175.as_str());
    }
    if let Some(var_176) = &input.next_token {
        object.key("NextToken").string(var_176);
    }
    if let Some(var_177) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_177).into()),
        );
    }
}

pub fn serialize_structure_crate_input_list_gateway_groups_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListGatewayGroupsInput,
) {
    if let Some(var_178) = &input.next_token {
        object.key("NextToken").string(var_178);
    }
    if let Some(var_179) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_179).into()),
        );
    }
}

pub fn serialize_structure_crate_input_list_gateways_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListGatewaysInput,
) {
    if let Some(var_180) = &input.gateway_group_arn {
        object.key("GatewayGroupArn").string(var_180);
    }
    if let Some(var_181) = &input.next_token {
        object.key("NextToken").string(var_181);
    }
    if let Some(var_182) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_182).into()),
        );
    }
}

pub fn serialize_structure_crate_input_list_skills_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListSkillsInput,
) {
    if let Some(var_183) = &input.skill_group_arn {
        object.key("SkillGroupArn").string(var_183);
    }
    if let Some(var_184) = &input.enablement_type {
        object.key("EnablementType").string(var_184.as_str());
    }
    if let Some(var_185) = &input.skill_type {
        object.key("SkillType").string(var_185.as_str());
    }
    if let Some(var_186) = &input.next_token {
        object.key("NextToken").string(var_186);
    }
    if let Some(var_187) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_187).into()),
        );
    }
}

pub fn serialize_structure_crate_input_list_skills_store_categories_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListSkillsStoreCategoriesInput,
) {
    if let Some(var_188) = &input.next_token {
        object.key("NextToken").string(var_188);
    }
    if let Some(var_189) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_189).into()),
        );
    }
}

pub fn serialize_structure_crate_input_list_skills_store_skills_by_category_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListSkillsStoreSkillsByCategoryInput,
) {
    if let Some(var_190) = &input.category_id {
        object.key("CategoryId").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_190).into()),
        );
    }
    if let Some(var_191) = &input.next_token {
        object.key("NextToken").string(var_191);
    }
    if let Some(var_192) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_192).into()),
        );
    }
}

pub fn serialize_structure_crate_input_list_smart_home_appliances_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListSmartHomeAppliancesInput,
) {
    if let Some(var_193) = &input.room_arn {
        object.key("RoomArn").string(var_193);
    }
    if let Some(var_194) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_194).into()),
        );
    }
    if let Some(var_195) = &input.next_token {
        object.key("NextToken").string(var_195);
    }
}

pub fn serialize_structure_crate_input_list_tags_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListTagsInput,
) {
    if let Some(var_196) = &input.arn {
        object.key("Arn").string(var_196);
    }
    if let Some(var_197) = &input.next_token {
        object.key("NextToken").string(var_197);
    }
    if let Some(var_198) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_198).into()),
        );
    }
}

pub fn serialize_structure_crate_input_put_conference_preference_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutConferencePreferenceInput,
) {
    if let Some(var_199) = &input.conference_preference {
        let mut object_200 = object.key("ConferencePreference").start_object();
        crate::json_ser::serialize_structure_crate_model_conference_preference(
            &mut object_200,
            var_199,
        );
        object_200.finish();
    }
}

pub fn serialize_structure_crate_input_put_invitation_configuration_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutInvitationConfigurationInput,
) {
    if let Some(var_201) = &input.organization_name {
        object.key("OrganizationName").string(var_201);
    }
    if let Some(var_202) = &input.contact_email {
        object.key("ContactEmail").string(var_202);
    }
    if let Some(var_203) = &input.private_skill_ids {
        let mut array_204 = object.key("PrivateSkillIds").start_array();
        for item_205 in var_203 {
            {
                array_204.value().string(item_205);
            }
        }
        array_204.finish();
    }
}

pub fn serialize_structure_crate_input_put_room_skill_parameter_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutRoomSkillParameterInput,
) {
    if let Some(var_206) = &input.room_arn {
        object.key("RoomArn").string(var_206);
    }
    if let Some(var_207) = &input.skill_id {
        object.key("SkillId").string(var_207);
    }
    if let Some(var_208) = &input.room_skill_parameter {
        let mut object_209 = object.key("RoomSkillParameter").start_object();
        crate::json_ser::serialize_structure_crate_model_room_skill_parameter(
            &mut object_209,
            var_208,
        );
        object_209.finish();
    }
}

pub fn serialize_structure_crate_input_put_skill_authorization_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutSkillAuthorizationInput,
) {
    if let Some(var_210) = &input.authorization_result {
        let mut object_211 = object.key("AuthorizationResult").start_object();
        for (key_212, value_213) in var_210 {
            {
                object_211.key(key_212).string(value_213);
            }
        }
        object_211.finish();
    }
    if let Some(var_214) = &input.skill_id {
        object.key("SkillId").string(var_214);
    }
    if let Some(var_215) = &input.room_arn {
        object.key("RoomArn").string(var_215);
    }
}

pub fn serialize_structure_crate_input_register_avs_device_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::RegisterAvsDeviceInput,
) {
    if let Some(var_216) = &input.client_id {
        object.key("ClientId").string(var_216);
    }
    if let Some(var_217) = &input.user_code {
        object.key("UserCode").string(var_217);
    }
    if let Some(var_218) = &input.product_id {
        object.key("ProductId").string(var_218);
    }
    if let Some(var_219) = &input.device_serial_number {
        object.key("DeviceSerialNumber").string(var_219);
    }
    if let Some(var_220) = &input.amazon_id {
        object.key("AmazonId").string(var_220);
    }
    if let Some(var_221) = &input.room_arn {
        object.key("RoomArn").string(var_221);
    }
    if let Some(var_222) = &input.tags {
        let mut array_223 = object.key("Tags").start_array();
        for item_224 in var_222 {
            {
                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();
    }
}

pub fn serialize_structure_crate_input_reject_skill_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::RejectSkillInput,
) {
    if let Some(var_226) = &input.skill_id {
        object.key("SkillId").string(var_226);
    }
}

pub fn serialize_structure_crate_input_resolve_room_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ResolveRoomInput,
) {
    if let Some(var_227) = &input.user_id {
        object.key("UserId").string(var_227);
    }
    if let Some(var_228) = &input.skill_id {
        object.key("SkillId").string(var_228);
    }
}

pub fn serialize_structure_crate_input_revoke_invitation_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::RevokeInvitationInput,
) {
    if let Some(var_229) = &input.user_arn {
        object.key("UserArn").string(var_229);
    }
    if let Some(var_230) = &input.enrollment_id {
        object.key("EnrollmentId").string(var_230);
    }
}

pub fn serialize_structure_crate_input_search_address_books_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::SearchAddressBooksInput,
) {
    if let Some(var_231) = &input.filters {
        let mut array_232 = object.key("Filters").start_array();
        for item_233 in var_231 {
            {
                let mut object_234 = array_232.value().start_object();
                crate::json_ser::serialize_structure_crate_model_filter(&mut object_234, item_233);
                object_234.finish();
            }
        }
        array_232.finish();
    }
    if let Some(var_235) = &input.sort_criteria {
        let mut array_236 = object.key("SortCriteria").start_array();
        for item_237 in var_235 {
            {
                let mut object_238 = array_236.value().start_object();
                crate::json_ser::serialize_structure_crate_model_sort(&mut object_238, item_237);
                object_238.finish();
            }
        }
        array_236.finish();
    }
    if let Some(var_239) = &input.next_token {
        object.key("NextToken").string(var_239);
    }
    if let Some(var_240) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_240).into()),
        );
    }
}

pub fn serialize_structure_crate_input_search_contacts_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::SearchContactsInput,
) {
    if let Some(var_241) = &input.filters {
        let mut array_242 = object.key("Filters").start_array();
        for item_243 in var_241 {
            {
                let mut object_244 = array_242.value().start_object();
                crate::json_ser::serialize_structure_crate_model_filter(&mut object_244, item_243);
                object_244.finish();
            }
        }
        array_242.finish();
    }
    if let Some(var_245) = &input.sort_criteria {
        let mut array_246 = object.key("SortCriteria").start_array();
        for item_247 in var_245 {
            {
                let mut object_248 = array_246.value().start_object();
                crate::json_ser::serialize_structure_crate_model_sort(&mut object_248, item_247);
                object_248.finish();
            }
        }
        array_246.finish();
    }
    if let Some(var_249) = &input.next_token {
        object.key("NextToken").string(var_249);
    }
    if let Some(var_250) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_250).into()),
        );
    }
}

pub fn serialize_structure_crate_input_search_devices_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::SearchDevicesInput,
) {
    if let Some(var_251) = &input.next_token {
        object.key("NextToken").string(var_251);
    }
    if let Some(var_252) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_252).into()),
        );
    }
    if let Some(var_253) = &input.filters {
        let mut array_254 = object.key("Filters").start_array();
        for item_255 in var_253 {
            {
                let mut object_256 = array_254.value().start_object();
                crate::json_ser::serialize_structure_crate_model_filter(&mut object_256, item_255);
                object_256.finish();
            }
        }
        array_254.finish();
    }
    if let Some(var_257) = &input.sort_criteria {
        let mut array_258 = object.key("SortCriteria").start_array();
        for item_259 in var_257 {
            {
                let mut object_260 = array_258.value().start_object();
                crate::json_ser::serialize_structure_crate_model_sort(&mut object_260, item_259);
                object_260.finish();
            }
        }
        array_258.finish();
    }
}

pub fn serialize_structure_crate_input_search_network_profiles_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::SearchNetworkProfilesInput,
) {
    if let Some(var_261) = &input.next_token {
        object.key("NextToken").string(var_261);
    }
    if let Some(var_262) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_262).into()),
        );
    }
    if let Some(var_263) = &input.filters {
        let mut array_264 = object.key("Filters").start_array();
        for item_265 in var_263 {
            {
                let mut object_266 = array_264.value().start_object();
                crate::json_ser::serialize_structure_crate_model_filter(&mut object_266, item_265);
                object_266.finish();
            }
        }
        array_264.finish();
    }
    if let Some(var_267) = &input.sort_criteria {
        let mut array_268 = object.key("SortCriteria").start_array();
        for item_269 in var_267 {
            {
                let mut object_270 = array_268.value().start_object();
                crate::json_ser::serialize_structure_crate_model_sort(&mut object_270, item_269);
                object_270.finish();
            }
        }
        array_268.finish();
    }
}

pub fn serialize_structure_crate_input_search_profiles_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::SearchProfilesInput,
) {
    if let Some(var_271) = &input.next_token {
        object.key("NextToken").string(var_271);
    }
    if let Some(var_272) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_272).into()),
        );
    }
    if let Some(var_273) = &input.filters {
        let mut array_274 = object.key("Filters").start_array();
        for item_275 in var_273 {
            {
                let mut object_276 = array_274.value().start_object();
                crate::json_ser::serialize_structure_crate_model_filter(&mut object_276, item_275);
                object_276.finish();
            }
        }
        array_274.finish();
    }
    if let Some(var_277) = &input.sort_criteria {
        let mut array_278 = object.key("SortCriteria").start_array();
        for item_279 in var_277 {
            {
                let mut object_280 = array_278.value().start_object();
                crate::json_ser::serialize_structure_crate_model_sort(&mut object_280, item_279);
                object_280.finish();
            }
        }
        array_278.finish();
    }
}

pub fn serialize_structure_crate_input_search_rooms_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::SearchRoomsInput,
) {
    if let Some(var_281) = &input.next_token {
        object.key("NextToken").string(var_281);
    }
    if let Some(var_282) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_282).into()),
        );
    }
    if let Some(var_283) = &input.filters {
        let mut array_284 = object.key("Filters").start_array();
        for item_285 in var_283 {
            {
                let mut object_286 = array_284.value().start_object();
                crate::json_ser::serialize_structure_crate_model_filter(&mut object_286, item_285);
                object_286.finish();
            }
        }
        array_284.finish();
    }
    if let Some(var_287) = &input.sort_criteria {
        let mut array_288 = object.key("SortCriteria").start_array();
        for item_289 in var_287 {
            {
                let mut object_290 = array_288.value().start_object();
                crate::json_ser::serialize_structure_crate_model_sort(&mut object_290, item_289);
                object_290.finish();
            }
        }
        array_288.finish();
    }
}

pub fn serialize_structure_crate_input_search_skill_groups_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::SearchSkillGroupsInput,
) {
    if let Some(var_291) = &input.next_token {
        object.key("NextToken").string(var_291);
    }
    if let Some(var_292) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_292).into()),
        );
    }
    if let Some(var_293) = &input.filters {
        let mut array_294 = object.key("Filters").start_array();
        for item_295 in var_293 {
            {
                let mut object_296 = array_294.value().start_object();
                crate::json_ser::serialize_structure_crate_model_filter(&mut object_296, item_295);
                object_296.finish();
            }
        }
        array_294.finish();
    }
    if let Some(var_297) = &input.sort_criteria {
        let mut array_298 = object.key("SortCriteria").start_array();
        for item_299 in var_297 {
            {
                let mut object_300 = array_298.value().start_object();
                crate::json_ser::serialize_structure_crate_model_sort(&mut object_300, item_299);
                object_300.finish();
            }
        }
        array_298.finish();
    }
}

pub fn serialize_structure_crate_input_search_users_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::SearchUsersInput,
) {
    if let Some(var_301) = &input.next_token {
        object.key("NextToken").string(var_301);
    }
    if let Some(var_302) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_302).into()),
        );
    }
    if let Some(var_303) = &input.filters {
        let mut array_304 = object.key("Filters").start_array();
        for item_305 in var_303 {
            {
                let mut object_306 = array_304.value().start_object();
                crate::json_ser::serialize_structure_crate_model_filter(&mut object_306, item_305);
                object_306.finish();
            }
        }
        array_304.finish();
    }
    if let Some(var_307) = &input.sort_criteria {
        let mut array_308 = object.key("SortCriteria").start_array();
        for item_309 in var_307 {
            {
                let mut object_310 = array_308.value().start_object();
                crate::json_ser::serialize_structure_crate_model_sort(&mut object_310, item_309);
                object_310.finish();
            }
        }
        array_308.finish();
    }
}

pub fn serialize_structure_crate_input_send_announcement_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::SendAnnouncementInput,
) {
    if let Some(var_311) = &input.room_filters {
        let mut array_312 = object.key("RoomFilters").start_array();
        for item_313 in var_311 {
            {
                let mut object_314 = array_312.value().start_object();
                crate::json_ser::serialize_structure_crate_model_filter(&mut object_314, item_313);
                object_314.finish();
            }
        }
        array_312.finish();
    }
    if let Some(var_315) = &input.content {
        let mut object_316 = object.key("Content").start_object();
        crate::json_ser::serialize_structure_crate_model_content(&mut object_316, var_315);
        object_316.finish();
    }
    if let Some(var_317) = &input.time_to_live_in_seconds {
        object.key("TimeToLiveInSeconds").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_317).into()),
        );
    }
    if let Some(var_318) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_318);
    }
}

pub fn serialize_structure_crate_input_send_invitation_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::SendInvitationInput,
) {
    if let Some(var_319) = &input.user_arn {
        object.key("UserArn").string(var_319);
    }
}

pub fn serialize_structure_crate_input_start_device_sync_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::StartDeviceSyncInput,
) {
    if let Some(var_320) = &input.room_arn {
        object.key("RoomArn").string(var_320);
    }
    if let Some(var_321) = &input.device_arn {
        object.key("DeviceArn").string(var_321);
    }
    if let Some(var_322) = &input.features {
        let mut array_323 = object.key("Features").start_array();
        for item_324 in var_322 {
            {
                array_323.value().string(item_324.as_str());
            }
        }
        array_323.finish();
    }
}

pub fn serialize_structure_crate_input_start_smart_home_appliance_discovery_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::StartSmartHomeApplianceDiscoveryInput,
) {
    if let Some(var_325) = &input.room_arn {
        object.key("RoomArn").string(var_325);
    }
}

pub fn serialize_structure_crate_input_tag_resource_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::TagResourceInput,
) {
    if let Some(var_326) = &input.arn {
        object.key("Arn").string(var_326);
    }
    if let Some(var_327) = &input.tags {
        let mut array_328 = object.key("Tags").start_array();
        for item_329 in var_327 {
            {
                let mut object_330 = array_328.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_330, item_329);
                object_330.finish();
            }
        }
        array_328.finish();
    }
}

pub fn serialize_structure_crate_input_untag_resource_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UntagResourceInput,
) {
    if let Some(var_331) = &input.arn {
        object.key("Arn").string(var_331);
    }
    if let Some(var_332) = &input.tag_keys {
        let mut array_333 = object.key("TagKeys").start_array();
        for item_334 in var_332 {
            {
                array_333.value().string(item_334);
            }
        }
        array_333.finish();
    }
}

pub fn serialize_structure_crate_input_update_address_book_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateAddressBookInput,
) {
    if let Some(var_335) = &input.address_book_arn {
        object.key("AddressBookArn").string(var_335);
    }
    if let Some(var_336) = &input.name {
        object.key("Name").string(var_336);
    }
    if let Some(var_337) = &input.description {
        object.key("Description").string(var_337);
    }
}

pub fn serialize_structure_crate_input_update_business_report_schedule_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateBusinessReportScheduleInput,
) {
    if let Some(var_338) = &input.schedule_arn {
        object.key("ScheduleArn").string(var_338);
    }
    if let Some(var_339) = &input.s3_bucket_name {
        object.key("S3BucketName").string(var_339);
    }
    if let Some(var_340) = &input.s3_key_prefix {
        object.key("S3KeyPrefix").string(var_340);
    }
    if let Some(var_341) = &input.format {
        object.key("Format").string(var_341.as_str());
    }
    if let Some(var_342) = &input.schedule_name {
        object.key("ScheduleName").string(var_342);
    }
    if let Some(var_343) = &input.recurrence {
        let mut object_344 = object.key("Recurrence").start_object();
        crate::json_ser::serialize_structure_crate_model_business_report_recurrence(
            &mut object_344,
            var_343,
        );
        object_344.finish();
    }
}

pub fn serialize_structure_crate_input_update_conference_provider_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateConferenceProviderInput,
) {
    if let Some(var_345) = &input.conference_provider_arn {
        object.key("ConferenceProviderArn").string(var_345);
    }
    if let Some(var_346) = &input.conference_provider_type {
        object
            .key("ConferenceProviderType")
            .string(var_346.as_str());
    }
    if let Some(var_347) = &input.ip_dial_in {
        let mut object_348 = object.key("IPDialIn").start_object();
        crate::json_ser::serialize_structure_crate_model_ip_dial_in(&mut object_348, var_347);
        object_348.finish();
    }
    if let Some(var_349) = &input.pstn_dial_in {
        let mut object_350 = object.key("PSTNDialIn").start_object();
        crate::json_ser::serialize_structure_crate_model_pstn_dial_in(&mut object_350, var_349);
        object_350.finish();
    }
    if let Some(var_351) = &input.meeting_setting {
        let mut object_352 = object.key("MeetingSetting").start_object();
        crate::json_ser::serialize_structure_crate_model_meeting_setting(&mut object_352, var_351);
        object_352.finish();
    }
}

pub fn serialize_structure_crate_input_update_contact_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateContactInput,
) {
    if let Some(var_353) = &input.contact_arn {
        object.key("ContactArn").string(var_353);
    }
    if let Some(var_354) = &input.display_name {
        object.key("DisplayName").string(var_354);
    }
    if let Some(var_355) = &input.first_name {
        object.key("FirstName").string(var_355);
    }
    if let Some(var_356) = &input.last_name {
        object.key("LastName").string(var_356);
    }
    if let Some(var_357) = &input.phone_number {
        object.key("PhoneNumber").string(var_357);
    }
    if let Some(var_358) = &input.phone_numbers {
        let mut array_359 = object.key("PhoneNumbers").start_array();
        for item_360 in var_358 {
            {
                let mut object_361 = array_359.value().start_object();
                crate::json_ser::serialize_structure_crate_model_phone_number(
                    &mut object_361,
                    item_360,
                );
                object_361.finish();
            }
        }
        array_359.finish();
    }
    if let Some(var_362) = &input.sip_addresses {
        let mut array_363 = object.key("SipAddresses").start_array();
        for item_364 in var_362 {
            {
                let mut object_365 = array_363.value().start_object();
                crate::json_ser::serialize_structure_crate_model_sip_address(
                    &mut object_365,
                    item_364,
                );
                object_365.finish();
            }
        }
        array_363.finish();
    }
}

pub fn serialize_structure_crate_input_update_device_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateDeviceInput,
) {
    if let Some(var_366) = &input.device_arn {
        object.key("DeviceArn").string(var_366);
    }
    if let Some(var_367) = &input.device_name {
        object.key("DeviceName").string(var_367);
    }
}

pub fn serialize_structure_crate_input_update_gateway_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateGatewayInput,
) {
    if let Some(var_368) = &input.gateway_arn {
        object.key("GatewayArn").string(var_368);
    }
    if let Some(var_369) = &input.name {
        object.key("Name").string(var_369);
    }
    if let Some(var_370) = &input.description {
        object.key("Description").string(var_370);
    }
    if let Some(var_371) = &input.software_version {
        object.key("SoftwareVersion").string(var_371);
    }
}

pub fn serialize_structure_crate_input_update_gateway_group_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateGatewayGroupInput,
) {
    if let Some(var_372) = &input.gateway_group_arn {
        object.key("GatewayGroupArn").string(var_372);
    }
    if let Some(var_373) = &input.name {
        object.key("Name").string(var_373);
    }
    if let Some(var_374) = &input.description {
        object.key("Description").string(var_374);
    }
}

pub fn serialize_structure_crate_input_update_network_profile_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateNetworkProfileInput,
) {
    if let Some(var_375) = &input.network_profile_arn {
        object.key("NetworkProfileArn").string(var_375);
    }
    if let Some(var_376) = &input.network_profile_name {
        object.key("NetworkProfileName").string(var_376);
    }
    if let Some(var_377) = &input.description {
        object.key("Description").string(var_377);
    }
    if let Some(var_378) = &input.current_password {
        object.key("CurrentPassword").string(var_378);
    }
    if let Some(var_379) = &input.next_password {
        object.key("NextPassword").string(var_379);
    }
    if let Some(var_380) = &input.certificate_authority_arn {
        object.key("CertificateAuthorityArn").string(var_380);
    }
    if let Some(var_381) = &input.trust_anchors {
        let mut array_382 = object.key("TrustAnchors").start_array();
        for item_383 in var_381 {
            {
                array_382.value().string(item_383);
            }
        }
        array_382.finish();
    }
}

pub fn serialize_structure_crate_input_update_profile_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateProfileInput,
) {
    if let Some(var_384) = &input.profile_arn {
        object.key("ProfileArn").string(var_384);
    }
    if let Some(var_385) = &input.profile_name {
        object.key("ProfileName").string(var_385);
    }
    if let Some(var_386) = &input.is_default {
        object.key("IsDefault").boolean(*var_386);
    }
    if let Some(var_387) = &input.timezone {
        object.key("Timezone").string(var_387);
    }
    if let Some(var_388) = &input.address {
        object.key("Address").string(var_388);
    }
    if let Some(var_389) = &input.distance_unit {
        object.key("DistanceUnit").string(var_389.as_str());
    }
    if let Some(var_390) = &input.temperature_unit {
        object.key("TemperatureUnit").string(var_390.as_str());
    }
    if let Some(var_391) = &input.wake_word {
        object.key("WakeWord").string(var_391.as_str());
    }
    if let Some(var_392) = &input.locale {
        object.key("Locale").string(var_392);
    }
    if let Some(var_393) = &input.setup_mode_disabled {
        object.key("SetupModeDisabled").boolean(*var_393);
    }
    if let Some(var_394) = &input.max_volume_limit {
        object.key("MaxVolumeLimit").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_394).into()),
        );
    }
    if let Some(var_395) = &input.pstn_enabled {
        object.key("PSTNEnabled").boolean(*var_395);
    }
    if let Some(var_396) = &input.data_retention_opt_in {
        object.key("DataRetentionOptIn").boolean(*var_396);
    }
    if let Some(var_397) = &input.meeting_room_configuration {
        let mut object_398 = object.key("MeetingRoomConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_update_meeting_room_configuration(
            &mut object_398,
            var_397,
        );
        object_398.finish();
    }
}

pub fn serialize_structure_crate_input_update_room_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateRoomInput,
) {
    if let Some(var_399) = &input.room_arn {
        object.key("RoomArn").string(var_399);
    }
    if let Some(var_400) = &input.room_name {
        object.key("RoomName").string(var_400);
    }
    if let Some(var_401) = &input.description {
        object.key("Description").string(var_401);
    }
    if let Some(var_402) = &input.provider_calendar_id {
        object.key("ProviderCalendarId").string(var_402);
    }
    if let Some(var_403) = &input.profile_arn {
        object.key("ProfileArn").string(var_403);
    }
}

pub fn serialize_structure_crate_input_update_skill_group_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateSkillGroupInput,
) {
    if let Some(var_404) = &input.skill_group_arn {
        object.key("SkillGroupArn").string(var_404);
    }
    if let Some(var_405) = &input.skill_group_name {
        object.key("SkillGroupName").string(var_405);
    }
    if let Some(var_406) = &input.description {
        object.key("Description").string(var_406);
    }
}

pub fn serialize_structure_crate_model_tag(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Tag,
) {
    if let Some(var_407) = &input.key {
        object.key("Key").string(var_407);
    }
    if let Some(var_408) = &input.value {
        object.key("Value").string(var_408);
    }
}

pub fn serialize_structure_crate_model_business_report_content_range(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::BusinessReportContentRange,
) {
    if let Some(var_409) = &input.interval {
        object.key("Interval").string(var_409.as_str());
    }
}

pub fn serialize_structure_crate_model_business_report_recurrence(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::BusinessReportRecurrence,
) {
    if let Some(var_410) = &input.start_date {
        object.key("StartDate").string(var_410);
    }
}

pub fn serialize_structure_crate_model_ip_dial_in(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::IpDialIn,
) {
    if let Some(var_411) = &input.endpoint {
        object.key("Endpoint").string(var_411);
    }
    if let Some(var_412) = &input.comms_protocol {
        object.key("CommsProtocol").string(var_412.as_str());
    }
}

pub fn serialize_structure_crate_model_pstn_dial_in(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::PstnDialIn,
) {
    if let Some(var_413) = &input.country_code {
        object.key("CountryCode").string(var_413);
    }
    if let Some(var_414) = &input.phone_number {
        object.key("PhoneNumber").string(var_414);
    }
    if let Some(var_415) = &input.one_click_id_delay {
        object.key("OneClickIdDelay").string(var_415);
    }
    if let Some(var_416) = &input.one_click_pin_delay {
        object.key("OneClickPinDelay").string(var_416);
    }
}

pub fn serialize_structure_crate_model_meeting_setting(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MeetingSetting,
) {
    if let Some(var_417) = &input.require_pin {
        object.key("RequirePin").string(var_417.as_str());
    }
}

pub fn serialize_structure_crate_model_phone_number(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::PhoneNumber,
) {
    if let Some(var_418) = &input.number {
        object.key("Number").string(var_418);
    }
    if let Some(var_419) = &input.r#type {
        object.key("Type").string(var_419.as_str());
    }
}

pub fn serialize_structure_crate_model_sip_address(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::SipAddress,
) {
    if let Some(var_420) = &input.uri {
        object.key("Uri").string(var_420);
    }
    if let Some(var_421) = &input.r#type {
        object.key("Type").string(var_421.as_str());
    }
}

pub fn serialize_structure_crate_model_create_meeting_room_configuration(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::CreateMeetingRoomConfiguration,
) {
    if let Some(var_422) = &input.room_utilization_metrics_enabled {
        object
            .key("RoomUtilizationMetricsEnabled")
            .boolean(*var_422);
    }
    if let Some(var_423) = &input.end_of_meeting_reminder {
        let mut object_424 = object.key("EndOfMeetingReminder").start_object();
        crate::json_ser::serialize_structure_crate_model_create_end_of_meeting_reminder(
            &mut object_424,
            var_423,
        );
        object_424.finish();
    }
    if let Some(var_425) = &input.instant_booking {
        let mut object_426 = object.key("InstantBooking").start_object();
        crate::json_ser::serialize_structure_crate_model_create_instant_booking(
            &mut object_426,
            var_425,
        );
        object_426.finish();
    }
    if let Some(var_427) = &input.require_check_in {
        let mut object_428 = object.key("RequireCheckIn").start_object();
        crate::json_ser::serialize_structure_crate_model_create_require_check_in(
            &mut object_428,
            var_427,
        );
        object_428.finish();
    }
}

pub fn serialize_structure_crate_model_conference_preference(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ConferencePreference,
) {
    if let Some(var_429) = &input.default_conference_provider_arn {
        object.key("DefaultConferenceProviderArn").string(var_429);
    }
}

pub fn serialize_structure_crate_model_room_skill_parameter(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::RoomSkillParameter,
) {
    if let Some(var_430) = &input.parameter_key {
        object.key("ParameterKey").string(var_430);
    }
    if let Some(var_431) = &input.parameter_value {
        object.key("ParameterValue").string(var_431);
    }
}

pub fn serialize_structure_crate_model_filter(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Filter,
) {
    if let Some(var_432) = &input.key {
        object.key("Key").string(var_432);
    }
    if let Some(var_433) = &input.values {
        let mut array_434 = object.key("Values").start_array();
        for item_435 in var_433 {
            {
                array_434.value().string(item_435);
            }
        }
        array_434.finish();
    }
}

pub fn serialize_structure_crate_model_sort(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Sort,
) {
    if let Some(var_436) = &input.key {
        object.key("Key").string(var_436);
    }
    if let Some(var_437) = &input.value {
        object.key("Value").string(var_437.as_str());
    }
}

pub fn serialize_structure_crate_model_content(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Content,
) {
    if let Some(var_438) = &input.text_list {
        let mut array_439 = object.key("TextList").start_array();
        for item_440 in var_438 {
            {
                let mut object_441 = array_439.value().start_object();
                crate::json_ser::serialize_structure_crate_model_text(&mut object_441, item_440);
                object_441.finish();
            }
        }
        array_439.finish();
    }
    if let Some(var_442) = &input.ssml_list {
        let mut array_443 = object.key("SsmlList").start_array();
        for item_444 in var_442 {
            {
                let mut object_445 = array_443.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ssml(&mut object_445, item_444);
                object_445.finish();
            }
        }
        array_443.finish();
    }
    if let Some(var_446) = &input.audio_list {
        let mut array_447 = object.key("AudioList").start_array();
        for item_448 in var_446 {
            {
                let mut object_449 = array_447.value().start_object();
                crate::json_ser::serialize_structure_crate_model_audio(&mut object_449, item_448);
                object_449.finish();
            }
        }
        array_447.finish();
    }
}

pub fn serialize_structure_crate_model_update_meeting_room_configuration(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::UpdateMeetingRoomConfiguration,
) {
    if let Some(var_450) = &input.room_utilization_metrics_enabled {
        object
            .key("RoomUtilizationMetricsEnabled")
            .boolean(*var_450);
    }
    if let Some(var_451) = &input.end_of_meeting_reminder {
        let mut object_452 = object.key("EndOfMeetingReminder").start_object();
        crate::json_ser::serialize_structure_crate_model_update_end_of_meeting_reminder(
            &mut object_452,
            var_451,
        );
        object_452.finish();
    }
    if let Some(var_453) = &input.instant_booking {
        let mut object_454 = object.key("InstantBooking").start_object();
        crate::json_ser::serialize_structure_crate_model_update_instant_booking(
            &mut object_454,
            var_453,
        );
        object_454.finish();
    }
    if let Some(var_455) = &input.require_check_in {
        let mut object_456 = object.key("RequireCheckIn").start_object();
        crate::json_ser::serialize_structure_crate_model_update_require_check_in(
            &mut object_456,
            var_455,
        );
        object_456.finish();
    }
}

pub fn serialize_structure_crate_model_create_end_of_meeting_reminder(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::CreateEndOfMeetingReminder,
) {
    if let Some(var_457) = &input.reminder_at_minutes {
        let mut array_458 = object.key("ReminderAtMinutes").start_array();
        for item_459 in var_457 {
            {
                array_458.value().number(
                    #[allow(clippy::useless_conversion)]
                    smithy_types::Number::NegInt((*item_459).into()),
                );
            }
        }
        array_458.finish();
    }
    if let Some(var_460) = &input.reminder_type {
        object.key("ReminderType").string(var_460.as_str());
    }
    if let Some(var_461) = &input.enabled {
        object.key("Enabled").boolean(*var_461);
    }
}

pub fn serialize_structure_crate_model_create_instant_booking(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::CreateInstantBooking,
) {
    if let Some(var_462) = &input.duration_in_minutes {
        object.key("DurationInMinutes").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_462).into()),
        );
    }
    if let Some(var_463) = &input.enabled {
        object.key("Enabled").boolean(*var_463);
    }
}

pub fn serialize_structure_crate_model_create_require_check_in(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::CreateRequireCheckIn,
) {
    if let Some(var_464) = &input.release_after_minutes {
        object.key("ReleaseAfterMinutes").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_464).into()),
        );
    }
    if let Some(var_465) = &input.enabled {
        object.key("Enabled").boolean(*var_465);
    }
}

pub fn serialize_structure_crate_model_text(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Text,
) {
    if let Some(var_466) = &input.locale {
        object.key("Locale").string(var_466.as_str());
    }
    if let Some(var_467) = &input.value {
        object.key("Value").string(var_467);
    }
}

pub fn serialize_structure_crate_model_ssml(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Ssml,
) {
    if let Some(var_468) = &input.locale {
        object.key("Locale").string(var_468.as_str());
    }
    if let Some(var_469) = &input.value {
        object.key("Value").string(var_469);
    }
}

pub fn serialize_structure_crate_model_audio(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Audio,
) {
    if let Some(var_470) = &input.locale {
        object.key("Locale").string(var_470.as_str());
    }
    if let Some(var_471) = &input.location {
        object.key("Location").string(var_471);
    }
}

pub fn serialize_structure_crate_model_update_end_of_meeting_reminder(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::UpdateEndOfMeetingReminder,
) {
    if let Some(var_472) = &input.reminder_at_minutes {
        let mut array_473 = object.key("ReminderAtMinutes").start_array();
        for item_474 in var_472 {
            {
                array_473.value().number(
                    #[allow(clippy::useless_conversion)]
                    smithy_types::Number::NegInt((*item_474).into()),
                );
            }
        }
        array_473.finish();
    }
    if let Some(var_475) = &input.reminder_type {
        object.key("ReminderType").string(var_475.as_str());
    }
    if let Some(var_476) = &input.enabled {
        object.key("Enabled").boolean(*var_476);
    }
}

pub fn serialize_structure_crate_model_update_instant_booking(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::UpdateInstantBooking,
) {
    if let Some(var_477) = &input.duration_in_minutes {
        object.key("DurationInMinutes").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_477).into()),
        );
    }
    if let Some(var_478) = &input.enabled {
        object.key("Enabled").boolean(*var_478);
    }
}

pub fn serialize_structure_crate_model_update_require_check_in(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::UpdateRequireCheckIn,
) {
    if let Some(var_479) = &input.release_after_minutes {
        object.key("ReleaseAfterMinutes").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_479).into()),
        );
    }
    if let Some(var_480) = &input.enabled {
        object.key("Enabled").boolean(*var_480);
    }
}
