pub fn serialize_structure_crate_input_approve_skill_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ApproveSkillInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.skill_id {
object.key("SkillId").string(var_1.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_contact_with_address_book_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateContactWithAddressBookInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2) = &input.contact_arn {
object.key("ContactArn").string(var_2.as_str());
}
if let Some(var_3) = &input.address_book_arn {
object.key("AddressBookArn").string(var_3.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_device_with_network_profile_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateDeviceWithNetworkProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_4) = &input.device_arn {
object.key("DeviceArn").string(var_4.as_str());
}
if let Some(var_5) = &input.network_profile_arn {
object.key("NetworkProfileArn").string(var_5.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_device_with_room_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateDeviceWithRoomInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_6) = &input.device_arn {
object.key("DeviceArn").string(var_6.as_str());
}
if let Some(var_7) = &input.room_arn {
object.key("RoomArn").string(var_7.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_skill_group_with_room_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateSkillGroupWithRoomInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_8) = &input.skill_group_arn {
object.key("SkillGroupArn").string(var_8.as_str());
}
if let Some(var_9) = &input.room_arn {
object.key("RoomArn").string(var_9.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_skill_with_skill_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateSkillWithSkillGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_10) = &input.skill_group_arn {
object.key("SkillGroupArn").string(var_10.as_str());
}
if let Some(var_11) = &input.skill_id {
object.key("SkillId").string(var_11.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_skill_with_users_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateSkillWithUsersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_12) = &input.skill_id {
object.key("SkillId").string(var_12.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_address_book_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAddressBookInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_13) = &input.name {
object.key("Name").string(var_13.as_str());
}
if let Some(var_14) = &input.description {
object.key("Description").string(var_14.as_str());
}
if let Some(var_15) = &input.client_request_token {
object.key("ClientRequestToken").string(var_15.as_str());
}
if let Some(var_16) = &input.tags {
let mut array_17 = object.key("Tags").start_array();
for item_18 in var_16 {
{
#[allow(unused_mut)]
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();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_business_report_schedule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBusinessReportScheduleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_20) = &input.schedule_name {
object.key("ScheduleName").string(var_20.as_str());
}
if let Some(var_21) = &input.s3_bucket_name {
object.key("S3BucketName").string(var_21.as_str());
}
if let Some(var_22) = &input.s3_key_prefix {
object.key("S3KeyPrefix").string(var_22.as_str());
}
if let Some(var_23) = &input.format {
object.key("Format").string(var_23.as_str());
}
if let Some(var_24) = &input.content_range {
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
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.as_str());
}
if let Some(var_29) = &input.tags {
let mut array_30 = object.key("Tags").start_array();
for item_31 in var_29 {
{
#[allow(unused_mut)]
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();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_conference_provider_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateConferenceProviderInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_33) = &input.conference_provider_name {
object.key("ConferenceProviderName").string(var_33.as_str());
}
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 {
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
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.as_str());
}
if let Some(var_42) = &input.tags {
let mut array_43 = object.key("Tags").start_array();
for item_44 in var_42 {
{
#[allow(unused_mut)]
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();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_contact_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateContactInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_46) = &input.display_name {
object.key("DisplayName").string(var_46.as_str());
}
if let Some(var_47) = &input.first_name {
object.key("FirstName").string(var_47.as_str());
}
if let Some(var_48) = &input.last_name {
object.key("LastName").string(var_48.as_str());
}
if let Some(var_49) = &input.phone_number {
object.key("PhoneNumber").string(var_49.as_str());
}
if let Some(var_50) = &input.phone_numbers {
let mut array_51 = object.key("PhoneNumbers").start_array();
for item_52 in var_50 {
{
#[allow(unused_mut)]
let mut object_53 = array_51.value().start_object();
crate::json_ser::serialize_structure_crate_model_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 {
{
#[allow(unused_mut)]
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.as_str());
}
if let Some(var_59) = &input.tags {
let mut array_60 = object.key("Tags").start_array();
for item_61 in var_59 {
{
#[allow(unused_mut)]
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();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_gateway_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateGatewayGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_63) = &input.name {
object.key("Name").string(var_63.as_str());
}
if let Some(var_64) = &input.description {
object.key("Description").string(var_64.as_str());
}
if let Some(var_65) = &input.client_request_token {
object.key("ClientRequestToken").string(var_65.as_str());
}
if let Some(var_66) = &input.tags {
let mut array_67 = object.key("Tags").start_array();
for item_68 in var_66 {
{
#[allow(unused_mut)]
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();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_network_profile_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateNetworkProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_70) = &input.network_profile_name {
object.key("NetworkProfileName").string(var_70.as_str());
}
if let Some(var_71) = &input.description {
object.key("Description").string(var_71.as_str());
}
if let Some(var_72) = &input.ssid {
object.key("Ssid").string(var_72.as_str());
}
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.as_str());
}
if let Some(var_76) = &input.next_password {
object.key("NextPassword").string(var_76.as_str());
}
if let Some(var_77) = &input.certificate_authority_arn {
object
.key("CertificateAuthorityArn")
.string(var_77.as_str());
}
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.as_str());
}
}
array_79.finish();
}
if let Some(var_81) = &input.client_request_token {
object.key("ClientRequestToken").string(var_81.as_str());
}
if let Some(var_82) = &input.tags {
let mut array_83 = object.key("Tags").start_array();
for item_84 in var_82 {
{
#[allow(unused_mut)]
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();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_profile_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_86) = &input.profile_name {
object.key("ProfileName").string(var_86.as_str());
}
if let Some(var_87) = &input.timezone {
object.key("Timezone").string(var_87.as_str());
}
if let Some(var_88) = &input.address {
object.key("Address").string(var_88.as_str());
}
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.as_str());
}
if let Some(var_93) = &input.client_request_token {
object.key("ClientRequestToken").string(var_93.as_str());
}
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)]
aws_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 {
#[allow(unused_mut)]
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 {
{
#[allow(unused_mut)]
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();
}
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_104) = &input.room_name {
object.key("RoomName").string(var_104.as_str());
}
if let Some(var_105) = &input.description {
object.key("Description").string(var_105.as_str());
}
if let Some(var_106) = &input.profile_arn {
object.key("ProfileArn").string(var_106.as_str());
}
if let Some(var_107) = &input.provider_calendar_id {
object.key("ProviderCalendarId").string(var_107.as_str());
}
if let Some(var_108) = &input.client_request_token {
object.key("ClientRequestToken").string(var_108.as_str());
}
if let Some(var_109) = &input.tags {
let mut array_110 = object.key("Tags").start_array();
for item_111 in var_109 {
{
#[allow(unused_mut)]
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();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_skill_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSkillGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_113) = &input.skill_group_name {
object.key("SkillGroupName").string(var_113.as_str());
}
if let Some(var_114) = &input.description {
object.key("Description").string(var_114.as_str());
}
if let Some(var_115) = &input.client_request_token {
object.key("ClientRequestToken").string(var_115.as_str());
}
if let Some(var_116) = &input.tags {
let mut array_117 = object.key("Tags").start_array();
for item_118 in var_116 {
{
#[allow(unused_mut)]
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();
}
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_120) = &input.user_id {
object.key("UserId").string(var_120.as_str());
}
if let Some(var_121) = &input.first_name {
object.key("FirstName").string(var_121.as_str());
}
if let Some(var_122) = &input.last_name {
object.key("LastName").string(var_122.as_str());
}
if let Some(var_123) = &input.email {
object.key("Email").string(var_123.as_str());
}
if let Some(var_124) = &input.client_request_token {
object.key("ClientRequestToken").string(var_124.as_str());
}
if let Some(var_125) = &input.tags {
let mut array_126 = object.key("Tags").start_array();
for item_127 in var_125 {
{
#[allow(unused_mut)]
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();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_address_book_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAddressBookInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_129) = &input.address_book_arn {
object.key("AddressBookArn").string(var_129.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_business_report_schedule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteBusinessReportScheduleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_130) = &input.schedule_arn {
object.key("ScheduleArn").string(var_130.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_conference_provider_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteConferenceProviderInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_131) = &input.conference_provider_arn {
object.key("ConferenceProviderArn").string(var_131.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_contact_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteContactInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_132) = &input.contact_arn {
object.key("ContactArn").string(var_132.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_device_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteDeviceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_133) = &input.device_arn {
object.key("DeviceArn").string(var_133.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_device_usage_data_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteDeviceUsageDataInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_134) = &input.device_arn {
object.key("DeviceArn").string(var_134.as_str());
}
if let Some(var_135) = &input.device_usage_type {
object.key("DeviceUsageType").string(var_135.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_gateway_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteGatewayGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_136) = &input.gateway_group_arn {
object.key("GatewayGroupArn").string(var_136.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_network_profile_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteNetworkProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_137) = &input.network_profile_arn {
object.key("NetworkProfileArn").string(var_137.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_profile_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_138) = &input.profile_arn {
object.key("ProfileArn").string(var_138.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_room_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteRoomInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_139) = &input.room_arn {
object.key("RoomArn").string(var_139.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_room_skill_parameter_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteRoomSkillParameterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_140) = &input.room_arn {
object.key("RoomArn").string(var_140.as_str());
}
if let Some(var_141) = &input.skill_id {
object.key("SkillId").string(var_141.as_str());
}
if let Some(var_142) = &input.parameter_key {
object.key("ParameterKey").string(var_142.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_skill_authorization_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteSkillAuthorizationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_143) = &input.skill_id {
object.key("SkillId").string(var_143.as_str());
}
if let Some(var_144) = &input.room_arn {
object.key("RoomArn").string(var_144.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_skill_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteSkillGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_145) = &input.skill_group_arn {
object.key("SkillGroupArn").string(var_145.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_user_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteUserInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_146) = &input.user_arn {
object.key("UserArn").string(var_146.as_str());
}
if let Some(var_147) = &input.enrollment_id {
object.key("EnrollmentId").string(var_147.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_contact_from_address_book_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateContactFromAddressBookInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_148) = &input.contact_arn {
object.key("ContactArn").string(var_148.as_str());
}
if let Some(var_149) = &input.address_book_arn {
object.key("AddressBookArn").string(var_149.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_device_from_room_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateDeviceFromRoomInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_150) = &input.device_arn {
object.key("DeviceArn").string(var_150.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_skill_from_skill_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateSkillFromSkillGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_151) = &input.skill_group_arn {
object.key("SkillGroupArn").string(var_151.as_str());
}
if let Some(var_152) = &input.skill_id {
object.key("SkillId").string(var_152.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_skill_from_users_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateSkillFromUsersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_153) = &input.skill_id {
object.key("SkillId").string(var_153.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_skill_group_from_room_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateSkillGroupFromRoomInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_154) = &input.skill_group_arn {
object.key("SkillGroupArn").string(var_154.as_str());
}
if let Some(var_155) = &input.room_arn {
object.key("RoomArn").string(var_155.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_forget_smart_home_appliances_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ForgetSmartHomeAppliancesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_156) = &input.room_arn {
object.key("RoomArn").string(var_156.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_address_book_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetAddressBookInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_157) = &input.address_book_arn {
object.key("AddressBookArn").string(var_157.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_conference_provider_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetConferenceProviderInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_158) = &input.conference_provider_arn {
object.key("ConferenceProviderArn").string(var_158.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_contact_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetContactInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_159) = &input.contact_arn {
object.key("ContactArn").string(var_159.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_device_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetDeviceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_160) = &input.device_arn {
object.key("DeviceArn").string(var_160.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_gateway_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetGatewayInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_161) = &input.gateway_arn {
object.key("GatewayArn").string(var_161.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_gateway_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetGatewayGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_162) = &input.gateway_group_arn {
object.key("GatewayGroupArn").string(var_162.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_network_profile_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetNetworkProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_163) = &input.network_profile_arn {
object.key("NetworkProfileArn").string(var_163.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_profile_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_164) = &input.profile_arn {
object.key("ProfileArn").string(var_164.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_room_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetRoomInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_165) = &input.room_arn {
object.key("RoomArn").string(var_165.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_room_skill_parameter_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetRoomSkillParameterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_166) = &input.room_arn {
object.key("RoomArn").string(var_166.as_str());
}
if let Some(var_167) = &input.skill_id {
object.key("SkillId").string(var_167.as_str());
}
if let Some(var_168) = &input.parameter_key {
object.key("ParameterKey").string(var_168.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_skill_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetSkillGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_169) = &input.skill_group_arn {
object.key("SkillGroupArn").string(var_169.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_business_report_schedules_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListBusinessReportSchedulesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_170) = &input.next_token {
object.key("NextToken").string(var_170.as_str());
}
if let Some(var_171) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_171).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_conference_providers_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListConferenceProvidersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_172) = &input.next_token {
object.key("NextToken").string(var_172.as_str());
}
if let Some(var_173) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_173).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_device_events_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDeviceEventsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_174) = &input.device_arn {
object.key("DeviceArn").string(var_174.as_str());
}
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.as_str());
}
if let Some(var_177) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_177).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_gateway_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListGatewayGroupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_178) = &input.next_token {
object.key("NextToken").string(var_178.as_str());
}
if let Some(var_179) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_179).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_gateways_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListGatewaysInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_180) = &input.gateway_group_arn {
object.key("GatewayGroupArn").string(var_180.as_str());
}
if let Some(var_181) = &input.next_token {
object.key("NextToken").string(var_181.as_str());
}
if let Some(var_182) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_182).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_skills_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSkillsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_183) = &input.skill_group_arn {
object.key("SkillGroupArn").string(var_183.as_str());
}
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.as_str());
}
if let Some(var_187) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_187).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_skills_store_categories_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSkillsStoreCategoriesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_188) = &input.next_token {
object.key("NextToken").string(var_188.as_str());
}
if let Some(var_189) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_189).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_skills_store_skills_by_category_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSkillsStoreSkillsByCategoryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_190) = &input.category_id {
object.key("CategoryId").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_190).into()),
);
}
if let Some(var_191) = &input.next_token {
object.key("NextToken").string(var_191.as_str());
}
if let Some(var_192) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_192).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_smart_home_appliances_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSmartHomeAppliancesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_193) = &input.room_arn {
object.key("RoomArn").string(var_193.as_str());
}
if let Some(var_194) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_194).into()),
);
}
if let Some(var_195) = &input.next_token {
object.key("NextToken").string(var_195.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tags_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTagsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_196) = &input.arn {
object.key("Arn").string(var_196.as_str());
}
if let Some(var_197) = &input.next_token {
object.key("NextToken").string(var_197.as_str());
}
if let Some(var_198) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_198).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_conference_preference_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutConferencePreferenceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_199) = &input.conference_preference {
#[allow(unused_mut)]
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();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_invitation_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutInvitationConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_201) = &input.organization_name {
object.key("OrganizationName").string(var_201.as_str());
}
if let Some(var_202) = &input.contact_email {
object.key("ContactEmail").string(var_202.as_str());
}
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.as_str());
}
}
array_204.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_room_skill_parameter_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutRoomSkillParameterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_206) = &input.room_arn {
object.key("RoomArn").string(var_206.as_str());
}
if let Some(var_207) = &input.skill_id {
object.key("SkillId").string(var_207.as_str());
}
if let Some(var_208) = &input.room_skill_parameter {
#[allow(unused_mut)]
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();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_skill_authorization_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutSkillAuthorizationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_210) = &input.authorization_result {
#[allow(unused_mut)]
let mut object_211 = object.key("AuthorizationResult").start_object();
for (key_212, value_213) in var_210 {
{
object_211.key(key_212.as_str()).string(value_213.as_str());
}
}
object_211.finish();
}
if let Some(var_214) = &input.skill_id {
object.key("SkillId").string(var_214.as_str());
}
if let Some(var_215) = &input.room_arn {
object.key("RoomArn").string(var_215.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_register_avs_device_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterAvsDeviceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_216) = &input.client_id {
object.key("ClientId").string(var_216.as_str());
}
if let Some(var_217) = &input.user_code {
object.key("UserCode").string(var_217.as_str());
}
if let Some(var_218) = &input.product_id {
object.key("ProductId").string(var_218.as_str());
}
if let Some(var_219) = &input.device_serial_number {
object.key("DeviceSerialNumber").string(var_219.as_str());
}
if let Some(var_220) = &input.amazon_id {
object.key("AmazonId").string(var_220.as_str());
}
if let Some(var_221) = &input.room_arn {
object.key("RoomArn").string(var_221.as_str());
}
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_reject_skill_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RejectSkillInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_226) = &input.skill_id {
object.key("SkillId").string(var_226.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_resolve_room_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ResolveRoomInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_227) = &input.user_id {
object.key("UserId").string(var_227.as_str());
}
if let Some(var_228) = &input.skill_id {
object.key("SkillId").string(var_228.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_revoke_invitation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RevokeInvitationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_229) = &input.user_arn {
object.key("UserArn").string(var_229.as_str());
}
if let Some(var_230) = &input.enrollment_id {
object.key("EnrollmentId").string(var_230.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_search_address_books_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchAddressBooksInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_231) = &input.filters {
let mut array_232 = object.key("Filters").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_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 {
{
#[allow(unused_mut)]
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.as_str());
}
if let Some(var_240) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_240).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_search_contacts_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchContactsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_241) = &input.filters {
let mut array_242 = object.key("Filters").start_array();
for item_243 in var_241 {
{
#[allow(unused_mut)]
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 {
{
#[allow(unused_mut)]
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.as_str());
}
if let Some(var_250) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_250).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_search_devices_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchDevicesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_251) = &input.next_token {
object.key("NextToken").string(var_251.as_str());
}
if let Some(var_252) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_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 {
{
#[allow(unused_mut)]
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 {
{
#[allow(unused_mut)]
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();
}
Ok(())
}
pub fn serialize_structure_crate_input_search_network_profiles_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchNetworkProfilesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_261) = &input.next_token {
object.key("NextToken").string(var_261.as_str());
}
if let Some(var_262) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_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 {
{
#[allow(unused_mut)]
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 {
{
#[allow(unused_mut)]
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();
}
Ok(())
}
pub fn serialize_structure_crate_input_search_profiles_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchProfilesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_271) = &input.next_token {
object.key("NextToken").string(var_271.as_str());
}
if let Some(var_272) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_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 {
{
#[allow(unused_mut)]
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 {
{
#[allow(unused_mut)]
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();
}
Ok(())
}
pub fn serialize_structure_crate_input_search_rooms_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchRoomsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_281) = &input.next_token {
object.key("NextToken").string(var_281.as_str());
}
if let Some(var_282) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_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 {
{
#[allow(unused_mut)]
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 {
{
#[allow(unused_mut)]
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();
}
Ok(())
}
pub fn serialize_structure_crate_input_search_skill_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchSkillGroupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_291) = &input.next_token {
object.key("NextToken").string(var_291.as_str());
}
if let Some(var_292) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_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 {
{
#[allow(unused_mut)]
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 {
{
#[allow(unused_mut)]
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();
}
Ok(())
}
pub fn serialize_structure_crate_input_search_users_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchUsersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_301) = &input.next_token {
object.key("NextToken").string(var_301.as_str());
}
if let Some(var_302) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_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 {
{
#[allow(unused_mut)]
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 {
{
#[allow(unused_mut)]
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();
}
Ok(())
}
pub fn serialize_structure_crate_input_send_announcement_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SendAnnouncementInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_311) = &input.room_filters {
let mut array_312 = object.key("RoomFilters").start_array();
for item_313 in var_311 {
{
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
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)]
aws_smithy_types::Number::NegInt((*var_317).into()),
);
}
if let Some(var_318) = &input.client_request_token {
object.key("ClientRequestToken").string(var_318.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_send_invitation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SendInvitationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_319) = &input.user_arn {
object.key("UserArn").string(var_319.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_device_sync_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartDeviceSyncInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_320) = &input.room_arn {
object.key("RoomArn").string(var_320.as_str());
}
if let Some(var_321) = &input.device_arn {
object.key("DeviceArn").string(var_321.as_str());
}
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();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_smart_home_appliance_discovery_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartSmartHomeApplianceDiscoveryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_325) = &input.room_arn {
object.key("RoomArn").string(var_325.as_str());
}
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_326) = &input.arn {
object.key("Arn").string(var_326.as_str());
}
if let Some(var_327) = &input.tags {
let mut array_328 = object.key("Tags").start_array();
for item_329 in var_327 {
{
#[allow(unused_mut)]
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();
}
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_331) = &input.arn {
object.key("Arn").string(var_331.as_str());
}
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.as_str());
}
}
array_333.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_address_book_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAddressBookInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_335) = &input.address_book_arn {
object.key("AddressBookArn").string(var_335.as_str());
}
if let Some(var_336) = &input.name {
object.key("Name").string(var_336.as_str());
}
if let Some(var_337) = &input.description {
object.key("Description").string(var_337.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_business_report_schedule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateBusinessReportScheduleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_338) = &input.schedule_arn {
object.key("ScheduleArn").string(var_338.as_str());
}
if let Some(var_339) = &input.s3_bucket_name {
object.key("S3BucketName").string(var_339.as_str());
}
if let Some(var_340) = &input.s3_key_prefix {
object.key("S3KeyPrefix").string(var_340.as_str());
}
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.as_str());
}
if let Some(var_343) = &input.recurrence {
#[allow(unused_mut)]
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();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_conference_provider_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateConferenceProviderInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_345) = &input.conference_provider_arn {
object.key("ConferenceProviderArn").string(var_345.as_str());
}
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 {
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
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();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_contact_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateContactInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_353) = &input.contact_arn {
object.key("ContactArn").string(var_353.as_str());
}
if let Some(var_354) = &input.display_name {
object.key("DisplayName").string(var_354.as_str());
}
if let Some(var_355) = &input.first_name {
object.key("FirstName").string(var_355.as_str());
}
if let Some(var_356) = &input.last_name {
object.key("LastName").string(var_356.as_str());
}
if let Some(var_357) = &input.phone_number {
object.key("PhoneNumber").string(var_357.as_str());
}
if let Some(var_358) = &input.phone_numbers {
let mut array_359 = object.key("PhoneNumbers").start_array();
for item_360 in var_358 {
{
#[allow(unused_mut)]
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 {
{
#[allow(unused_mut)]
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();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_device_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDeviceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_366) = &input.device_arn {
object.key("DeviceArn").string(var_366.as_str());
}
if let Some(var_367) = &input.device_name {
object.key("DeviceName").string(var_367.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_gateway_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateGatewayInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_368) = &input.gateway_arn {
object.key("GatewayArn").string(var_368.as_str());
}
if let Some(var_369) = &input.name {
object.key("Name").string(var_369.as_str());
}
if let Some(var_370) = &input.description {
object.key("Description").string(var_370.as_str());
}
if let Some(var_371) = &input.software_version {
object.key("SoftwareVersion").string(var_371.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_gateway_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateGatewayGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_372) = &input.gateway_group_arn {
object.key("GatewayGroupArn").string(var_372.as_str());
}
if let Some(var_373) = &input.name {
object.key("Name").string(var_373.as_str());
}
if let Some(var_374) = &input.description {
object.key("Description").string(var_374.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_network_profile_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateNetworkProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_375) = &input.network_profile_arn {
object.key("NetworkProfileArn").string(var_375.as_str());
}
if let Some(var_376) = &input.network_profile_name {
object.key("NetworkProfileName").string(var_376.as_str());
}
if let Some(var_377) = &input.description {
object.key("Description").string(var_377.as_str());
}
if let Some(var_378) = &input.current_password {
object.key("CurrentPassword").string(var_378.as_str());
}
if let Some(var_379) = &input.next_password {
object.key("NextPassword").string(var_379.as_str());
}
if let Some(var_380) = &input.certificate_authority_arn {
object
.key("CertificateAuthorityArn")
.string(var_380.as_str());
}
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.as_str());
}
}
array_382.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_profile_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_384) = &input.profile_arn {
object.key("ProfileArn").string(var_384.as_str());
}
if let Some(var_385) = &input.profile_name {
object.key("ProfileName").string(var_385.as_str());
}
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.as_str());
}
if let Some(var_388) = &input.address {
object.key("Address").string(var_388.as_str());
}
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.as_str());
}
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)]
aws_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 {
#[allow(unused_mut)]
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();
}
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_399) = &input.room_arn {
object.key("RoomArn").string(var_399.as_str());
}
if let Some(var_400) = &input.room_name {
object.key("RoomName").string(var_400.as_str());
}
if let Some(var_401) = &input.description {
object.key("Description").string(var_401.as_str());
}
if let Some(var_402) = &input.provider_calendar_id {
object.key("ProviderCalendarId").string(var_402.as_str());
}
if let Some(var_403) = &input.profile_arn {
object.key("ProfileArn").string(var_403.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_skill_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSkillGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_404) = &input.skill_group_arn {
object.key("SkillGroupArn").string(var_404.as_str());
}
if let Some(var_405) = &input.skill_group_name {
object.key("SkillGroupName").string(var_405.as_str());
}
if let Some(var_406) = &input.description {
object.key("Description").string(var_406.as_str());
}
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_407) = &input.key {
object.key("Key").string(var_407.as_str());
}
if let Some(var_408) = &input.value {
object.key("Value").string(var_408.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_business_report_content_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BusinessReportContentRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_409) = &input.interval {
object.key("Interval").string(var_409.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_business_report_recurrence(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BusinessReportRecurrence,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_410) = &input.start_date {
object.key("StartDate").string(var_410.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ip_dial_in(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IpDialIn,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_411) = &input.endpoint {
object.key("Endpoint").string(var_411.as_str());
}
if let Some(var_412) = &input.comms_protocol {
object.key("CommsProtocol").string(var_412.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_pstn_dial_in(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PstnDialIn,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_413) = &input.country_code {
object.key("CountryCode").string(var_413.as_str());
}
if let Some(var_414) = &input.phone_number {
object.key("PhoneNumber").string(var_414.as_str());
}
if let Some(var_415) = &input.one_click_id_delay {
object.key("OneClickIdDelay").string(var_415.as_str());
}
if let Some(var_416) = &input.one_click_pin_delay {
object.key("OneClickPinDelay").string(var_416.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_meeting_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MeetingSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_417) = &input.require_pin {
object.key("RequirePin").string(var_417.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_phone_number(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PhoneNumber,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_418) = &input.number {
object.key("Number").string(var_418.as_str());
}
if let Some(var_419) = &input.r#type {
object.key("Type").string(var_419.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sip_address(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SipAddress,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_420) = &input.uri {
object.key("Uri").string(var_420.as_str());
}
if let Some(var_421) = &input.r#type {
object.key("Type").string(var_421.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_create_meeting_room_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateMeetingRoomConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
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 {
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
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();
}
Ok(())
}
pub fn serialize_structure_crate_model_conference_preference(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConferencePreference,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_429) = &input.default_conference_provider_arn {
object
.key("DefaultConferenceProviderArn")
.string(var_429.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_room_skill_parameter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RoomSkillParameter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_430) = &input.parameter_key {
object.key("ParameterKey").string(var_430.as_str());
}
if let Some(var_431) = &input.parameter_value {
object.key("ParameterValue").string(var_431.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Filter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_432) = &input.key {
object.key("Key").string(var_432.as_str());
}
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.as_str());
}
}
array_434.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sort(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Sort,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_436) = &input.key {
object.key("Key").string(var_436.as_str());
}
if let Some(var_437) = &input.value {
object.key("Value").string(var_437.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_content(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Content,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_438) = &input.text_list {
let mut array_439 = object.key("TextList").start_array();
for item_440 in var_438 {
{
#[allow(unused_mut)]
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 {
{
#[allow(unused_mut)]
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 {
{
#[allow(unused_mut)]
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();
}
Ok(())
}
pub fn serialize_structure_crate_model_update_meeting_room_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateMeetingRoomConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
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 {
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
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();
}
Ok(())
}
pub fn serialize_structure_crate_model_create_end_of_meeting_reminder(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateEndOfMeetingReminder,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
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)]
aws_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);
}
Ok(())
}
pub fn serialize_structure_crate_model_create_instant_booking(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateInstantBooking,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_462) = &input.duration_in_minutes {
object.key("DurationInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_462).into()),
);
}
if let Some(var_463) = &input.enabled {
object.key("Enabled").boolean(*var_463);
}
Ok(())
}
pub fn serialize_structure_crate_model_create_require_check_in(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateRequireCheckIn,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_464) = &input.release_after_minutes {
object.key("ReleaseAfterMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_464).into()),
);
}
if let Some(var_465) = &input.enabled {
object.key("Enabled").boolean(*var_465);
}
Ok(())
}
pub fn serialize_structure_crate_model_text(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Text,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
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.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ssml(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Ssml,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
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.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_audio(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Audio,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
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.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_update_end_of_meeting_reminder(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateEndOfMeetingReminder,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
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)]
aws_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);
}
Ok(())
}
pub fn serialize_structure_crate_model_update_instant_booking(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateInstantBooking,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_477) = &input.duration_in_minutes {
object.key("DurationInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_477).into()),
);
}
if let Some(var_478) = &input.enabled {
object.key("Enabled").boolean(*var_478);
}
Ok(())
}
pub fn serialize_structure_crate_model_update_require_check_in(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateRequireCheckIn,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_479) = &input.release_after_minutes {
object.key("ReleaseAfterMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_479).into()),
);
}
if let Some(var_480) = &input.enabled {
object.key("Enabled").boolean(*var_480);
}
Ok(())
}