pub fn serialize_structure_crate_input_associate_phone_numbers_with_voice_connector_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociatePhoneNumbersWithVoiceConnectorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.e164_phone_numbers {
let mut array_2 = object.key("E164PhoneNumbers").start_array();
for item_3 in var_1 {
{
array_2.value().string(item_3.as_str());
}
}
array_2.finish();
}
if let Some(var_4) = &input.force_associate {
object.key("ForceAssociate").boolean(*var_4);
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_phone_numbers_with_voice_connector_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociatePhoneNumbersWithVoiceConnectorGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_5) = &input.e164_phone_numbers {
let mut array_6 = object.key("E164PhoneNumbers").start_array();
for item_7 in var_5 {
{
array_6.value().string(item_7.as_str());
}
}
array_6.finish();
}
if let Some(var_8) = &input.force_associate {
object.key("ForceAssociate").boolean(*var_8);
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_delete_phone_number_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchDeletePhoneNumberInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_9) = &input.phone_number_ids {
let mut array_10 = object.key("PhoneNumberIds").start_array();
for item_11 in var_9 {
{
array_10.value().string(item_11.as_str());
}
}
array_10.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_update_phone_number_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchUpdatePhoneNumberInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_12) = &input.update_phone_number_request_items {
let mut array_13 = object.key("UpdatePhoneNumberRequestItems").start_array();
for item_14 in var_12 {
{
#[allow(unused_mut)]
let mut object_15 = array_13.value().start_object();
crate::json_ser::serialize_structure_crate_model_update_phone_number_request_item(
&mut object_15,
item_14,
)?;
object_15.finish();
}
}
array_13.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_phone_number_order_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreatePhoneNumberOrderInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_16) = &input.e164_phone_numbers {
let mut array_17 = object.key("E164PhoneNumbers").start_array();
for item_18 in var_16 {
{
array_17.value().string(item_18.as_str());
}
}
array_17.finish();
}
if let Some(var_19) = &input.product_type {
object.key("ProductType").string(var_19.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_proxy_session_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateProxySessionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_20) = &input.capabilities {
let mut array_21 = object.key("Capabilities").start_array();
for item_22 in var_20 {
{
array_21.value().string(item_22.as_str());
}
}
array_21.finish();
}
if let Some(var_23) = &input.expiry_minutes {
object.key("ExpiryMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_23).into()),
);
}
if let Some(var_24) = &input.geo_match_level {
object.key("GeoMatchLevel").string(var_24.as_str());
}
if let Some(var_25) = &input.geo_match_params {
#[allow(unused_mut)]
let mut object_26 = object.key("GeoMatchParams").start_object();
crate::json_ser::serialize_structure_crate_model_geo_match_params(&mut object_26, var_25)?;
object_26.finish();
}
if let Some(var_27) = &input.name {
object.key("Name").string(var_27.as_str());
}
if let Some(var_28) = &input.number_selection_behavior {
object
.key("NumberSelectionBehavior")
.string(var_28.as_str());
}
if let Some(var_29) = &input.participant_phone_numbers {
let mut array_30 = object.key("ParticipantPhoneNumbers").start_array();
for item_31 in var_29 {
{
array_30.value().string(item_31.as_str());
}
}
array_30.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_sip_media_application_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSipMediaApplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_32) = &input.aws_region {
object.key("AwsRegion").string(var_32.as_str());
}
if let Some(var_33) = &input.endpoints {
let mut array_34 = object.key("Endpoints").start_array();
for item_35 in var_33 {
{
#[allow(unused_mut)]
let mut object_36 = array_34.value().start_object();
crate::json_ser::serialize_structure_crate_model_sip_media_application_endpoint(
&mut object_36,
item_35,
)?;
object_36.finish();
}
}
array_34.finish();
}
if let Some(var_37) = &input.name {
object.key("Name").string(var_37.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_sip_media_application_call_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSipMediaApplicationCallInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_38) = &input.arguments_map {
#[allow(unused_mut)]
let mut object_39 = object.key("ArgumentsMap").start_object();
for (key_40, value_41) in var_38 {
{
object_39.key(key_40.as_str()).string(value_41.as_str());
}
}
object_39.finish();
}
if let Some(var_42) = &input.from_phone_number {
object.key("FromPhoneNumber").string(var_42.as_str());
}
if let Some(var_43) = &input.sip_headers {
#[allow(unused_mut)]
let mut object_44 = object.key("SipHeaders").start_object();
for (key_45, value_46) in var_43 {
{
object_44.key(key_45.as_str()).string(value_46.as_str());
}
}
object_44.finish();
}
if let Some(var_47) = &input.to_phone_number {
object.key("ToPhoneNumber").string(var_47.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_sip_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSipRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_48) = &input.disabled {
object.key("Disabled").boolean(*var_48);
}
if let Some(var_49) = &input.name {
object.key("Name").string(var_49.as_str());
}
if let Some(var_50) = &input.target_applications {
let mut array_51 = object.key("TargetApplications").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_sip_rule_target_application(
&mut object_53,
item_52,
)?;
object_53.finish();
}
}
array_51.finish();
}
if let Some(var_54) = &input.trigger_type {
object.key("TriggerType").string(var_54.as_str());
}
if let Some(var_55) = &input.trigger_value {
object.key("TriggerValue").string(var_55.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_voice_connector_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateVoiceConnectorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_56) = &input.aws_region {
object.key("AwsRegion").string(var_56.as_str());
}
if let Some(var_57) = &input.name {
object.key("Name").string(var_57.as_str());
}
if let Some(var_58) = &input.require_encryption {
object.key("RequireEncryption").boolean(*var_58);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_voice_connector_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateVoiceConnectorGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_59) = &input.name {
object.key("Name").string(var_59.as_str());
}
if let Some(var_60) = &input.voice_connector_items {
let mut array_61 = object.key("VoiceConnectorItems").start_array();
for item_62 in var_60 {
{
#[allow(unused_mut)]
let mut object_63 = array_61.value().start_object();
crate::json_ser::serialize_structure_crate_model_voice_connector_item(
&mut object_63,
item_62,
)?;
object_63.finish();
}
}
array_61.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_voice_connector_termination_credentials_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteVoiceConnectorTerminationCredentialsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_64) = &input.usernames {
let mut array_65 = object.key("Usernames").start_array();
for item_66 in var_64 {
{
array_65.value().string(item_66.as_str());
}
}
array_65.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_phone_numbers_from_voice_connector_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociatePhoneNumbersFromVoiceConnectorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_67) = &input.e164_phone_numbers {
let mut array_68 = object.key("E164PhoneNumbers").start_array();
for item_69 in var_67 {
{
array_68.value().string(item_69.as_str());
}
}
array_68.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_phone_numbers_from_voice_connector_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociatePhoneNumbersFromVoiceConnectorGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_70) = &input.e164_phone_numbers {
let mut array_71 = object.key("E164PhoneNumbers").start_array();
for item_72 in var_70 {
{
array_71.value().string(item_72.as_str());
}
}
array_71.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_sip_media_application_alexa_skill_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutSipMediaApplicationAlexaSkillConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_73) = &input.sip_media_application_alexa_skill_configuration {
#[allow(unused_mut)]
let mut object_74 = object
.key("SipMediaApplicationAlexaSkillConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_sip_media_application_alexa_skill_configuration(&mut object_74, var_73)?;
object_74.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_sip_media_application_logging_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutSipMediaApplicationLoggingConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_75) = &input.sip_media_application_logging_configuration {
#[allow(unused_mut)]
let mut object_76 = object
.key("SipMediaApplicationLoggingConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_sip_media_application_logging_configuration(&mut object_76, var_75)?;
object_76.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_voice_connector_emergency_calling_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutVoiceConnectorEmergencyCallingConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_77) = &input.emergency_calling_configuration {
#[allow(unused_mut)]
let mut object_78 = object.key("EmergencyCallingConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_emergency_calling_configuration(
&mut object_78,
var_77,
)?;
object_78.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_voice_connector_logging_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutVoiceConnectorLoggingConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_79) = &input.logging_configuration {
#[allow(unused_mut)]
let mut object_80 = object.key("LoggingConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_logging_configuration(
&mut object_80,
var_79,
)?;
object_80.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_voice_connector_origination_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutVoiceConnectorOriginationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_81) = &input.origination {
#[allow(unused_mut)]
let mut object_82 = object.key("Origination").start_object();
crate::json_ser::serialize_structure_crate_model_origination(&mut object_82, var_81)?;
object_82.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_voice_connector_proxy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutVoiceConnectorProxyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_83) = &input.default_session_expiry_minutes {
object.key("DefaultSessionExpiryMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_83).into()),
);
}
if let Some(var_84) = &input.disabled {
object.key("Disabled").boolean(*var_84);
}
if let Some(var_85) = &input.fall_back_phone_number {
object.key("FallBackPhoneNumber").string(var_85.as_str());
}
if let Some(var_86) = &input.phone_number_pool_countries {
let mut array_87 = object.key("PhoneNumberPoolCountries").start_array();
for item_88 in var_86 {
{
array_87.value().string(item_88.as_str());
}
}
array_87.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_voice_connector_streaming_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutVoiceConnectorStreamingConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_89) = &input.streaming_configuration {
#[allow(unused_mut)]
let mut object_90 = object.key("StreamingConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_streaming_configuration(
&mut object_90,
var_89,
)?;
object_90.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_voice_connector_termination_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutVoiceConnectorTerminationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_91) = &input.termination {
#[allow(unused_mut)]
let mut object_92 = object.key("Termination").start_object();
crate::json_ser::serialize_structure_crate_model_termination(&mut object_92, var_91)?;
object_92.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_voice_connector_termination_credentials_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutVoiceConnectorTerminationCredentialsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_93) = &input.credentials {
let mut array_94 = object.key("Credentials").start_array();
for item_95 in var_93 {
{
#[allow(unused_mut)]
let mut object_96 = array_94.value().start_object();
crate::json_ser::serialize_structure_crate_model_credential(
&mut object_96,
item_95,
)?;
object_96.finish();
}
}
array_94.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_global_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateGlobalSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_97) = &input.voice_connector {
#[allow(unused_mut)]
let mut object_98 = object.key("VoiceConnector").start_object();
crate::json_ser::serialize_structure_crate_model_voice_connector_settings(
&mut object_98,
var_97,
)?;
object_98.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_phone_number_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdatePhoneNumberInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_99) = &input.calling_name {
object.key("CallingName").string(var_99.as_str());
}
if let Some(var_100) = &input.product_type {
object.key("ProductType").string(var_100.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_phone_number_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdatePhoneNumberSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_101) = &input.calling_name {
object.key("CallingName").string(var_101.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_proxy_session_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateProxySessionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_102) = &input.capabilities {
let mut array_103 = object.key("Capabilities").start_array();
for item_104 in var_102 {
{
array_103.value().string(item_104.as_str());
}
}
array_103.finish();
}
if let Some(var_105) = &input.expiry_minutes {
object.key("ExpiryMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_105).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_sip_media_application_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSipMediaApplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_106) = &input.endpoints {
let mut array_107 = object.key("Endpoints").start_array();
for item_108 in var_106 {
{
#[allow(unused_mut)]
let mut object_109 = array_107.value().start_object();
crate::json_ser::serialize_structure_crate_model_sip_media_application_endpoint(
&mut object_109,
item_108,
)?;
object_109.finish();
}
}
array_107.finish();
}
if let Some(var_110) = &input.name {
object.key("Name").string(var_110.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_sip_media_application_call_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSipMediaApplicationCallInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_111) = &input.arguments {
#[allow(unused_mut)]
let mut object_112 = object.key("Arguments").start_object();
for (key_113, value_114) in var_111 {
{
object_112.key(key_113.as_str()).string(value_114.as_str());
}
}
object_112.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_sip_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSipRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_115) = &input.disabled {
object.key("Disabled").boolean(*var_115);
}
if let Some(var_116) = &input.name {
object.key("Name").string(var_116.as_str());
}
if let Some(var_117) = &input.target_applications {
let mut array_118 = object.key("TargetApplications").start_array();
for item_119 in var_117 {
{
#[allow(unused_mut)]
let mut object_120 = array_118.value().start_object();
crate::json_ser::serialize_structure_crate_model_sip_rule_target_application(
&mut object_120,
item_119,
)?;
object_120.finish();
}
}
array_118.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_voice_connector_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateVoiceConnectorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_121) = &input.name {
object.key("Name").string(var_121.as_str());
}
if let Some(var_122) = &input.require_encryption {
object.key("RequireEncryption").boolean(*var_122);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_voice_connector_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateVoiceConnectorGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_123) = &input.name {
object.key("Name").string(var_123.as_str());
}
if let Some(var_124) = &input.voice_connector_items {
let mut array_125 = object.key("VoiceConnectorItems").start_array();
for item_126 in var_124 {
{
#[allow(unused_mut)]
let mut object_127 = array_125.value().start_object();
crate::json_ser::serialize_structure_crate_model_voice_connector_item(
&mut object_127,
item_126,
)?;
object_127.finish();
}
}
array_125.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_validate_e911_address_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ValidateE911AddressInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_128) = &input.aws_account_id {
object.key("AwsAccountId").string(var_128.as_str());
}
if let Some(var_129) = &input.city {
object.key("City").string(var_129.as_str());
}
if let Some(var_130) = &input.country {
object.key("Country").string(var_130.as_str());
}
if let Some(var_131) = &input.postal_code {
object.key("PostalCode").string(var_131.as_str());
}
if let Some(var_132) = &input.state {
object.key("State").string(var_132.as_str());
}
if let Some(var_133) = &input.street_info {
object.key("StreetInfo").string(var_133.as_str());
}
if let Some(var_134) = &input.street_number {
object.key("StreetNumber").string(var_134.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_update_phone_number_request_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdatePhoneNumberRequestItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_135) = &input.phone_number_id {
object.key("PhoneNumberId").string(var_135.as_str());
}
if let Some(var_136) = &input.product_type {
object.key("ProductType").string(var_136.as_str());
}
if let Some(var_137) = &input.calling_name {
object.key("CallingName").string(var_137.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_geo_match_params(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GeoMatchParams,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_138) = &input.country {
object.key("Country").string(var_138.as_str());
}
if let Some(var_139) = &input.area_code {
object.key("AreaCode").string(var_139.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sip_media_application_endpoint(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SipMediaApplicationEndpoint,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_140) = &input.lambda_arn {
object.key("LambdaArn").string(var_140.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sip_rule_target_application(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SipRuleTargetApplication,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_141) = &input.sip_media_application_id {
object.key("SipMediaApplicationId").string(var_141.as_str());
}
if let Some(var_142) = &input.priority {
object.key("Priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_142).into()),
);
}
if let Some(var_143) = &input.aws_region {
object.key("AwsRegion").string(var_143.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_voice_connector_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VoiceConnectorItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_144) = &input.voice_connector_id {
object.key("VoiceConnectorId").string(var_144.as_str());
}
if let Some(var_145) = &input.priority {
object.key("Priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_145).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_sip_media_application_alexa_skill_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SipMediaApplicationAlexaSkillConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_146) = &input.alexa_skill_status {
object.key("AlexaSkillStatus").string(var_146.as_str());
}
if let Some(var_147) = &input.alexa_skill_ids {
let mut array_148 = object.key("AlexaSkillIds").start_array();
for item_149 in var_147 {
{
array_148.value().string(item_149.as_str());
}
}
array_148.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sip_media_application_logging_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SipMediaApplicationLoggingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_150) = &input.enable_sip_media_application_message_logs {
object
.key("EnableSipMediaApplicationMessageLogs")
.boolean(*var_150);
}
Ok(())
}
pub fn serialize_structure_crate_model_emergency_calling_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EmergencyCallingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_151) = &input.dnis {
let mut array_152 = object.key("DNIS").start_array();
for item_153 in var_151 {
{
#[allow(unused_mut)]
let mut object_154 = array_152.value().start_object();
crate::json_ser::serialize_structure_crate_model_dnis_emergency_calling_configuration(&mut object_154, item_153)?;
object_154.finish();
}
}
array_152.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_logging_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoggingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_155) = &input.enable_sip_logs {
object.key("EnableSIPLogs").boolean(*var_155);
}
Ok(())
}
pub fn serialize_structure_crate_model_origination(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Origination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_156) = &input.routes {
let mut array_157 = object.key("Routes").start_array();
for item_158 in var_156 {
{
#[allow(unused_mut)]
let mut object_159 = array_157.value().start_object();
crate::json_ser::serialize_structure_crate_model_origination_route(
&mut object_159,
item_158,
)?;
object_159.finish();
}
}
array_157.finish();
}
if let Some(var_160) = &input.disabled {
object.key("Disabled").boolean(*var_160);
}
Ok(())
}
pub fn serialize_structure_crate_model_streaming_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StreamingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_161) = &input.data_retention_in_hours {
object.key("DataRetentionInHours").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_161).into()),
);
}
if let Some(var_162) = &input.disabled {
object.key("Disabled").boolean(*var_162);
}
if let Some(var_163) = &input.streaming_notification_targets {
let mut array_164 = object.key("StreamingNotificationTargets").start_array();
for item_165 in var_163 {
{
#[allow(unused_mut)]
let mut object_166 = array_164.value().start_object();
crate::json_ser::serialize_structure_crate_model_streaming_notification_target(
&mut object_166,
item_165,
)?;
object_166.finish();
}
}
array_164.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_termination(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Termination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_167) = &input.cps_limit {
object.key("CpsLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_167).into()),
);
}
if let Some(var_168) = &input.default_phone_number {
object.key("DefaultPhoneNumber").string(var_168.as_str());
}
if let Some(var_169) = &input.calling_regions {
let mut array_170 = object.key("CallingRegions").start_array();
for item_171 in var_169 {
{
array_170.value().string(item_171.as_str());
}
}
array_170.finish();
}
if let Some(var_172) = &input.cidr_allowed_list {
let mut array_173 = object.key("CidrAllowedList").start_array();
for item_174 in var_172 {
{
array_173.value().string(item_174.as_str());
}
}
array_173.finish();
}
if let Some(var_175) = &input.disabled {
object.key("Disabled").boolean(*var_175);
}
Ok(())
}
pub fn serialize_structure_crate_model_credential(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Credential,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_176) = &input.username {
object.key("Username").string(var_176.as_str());
}
if let Some(var_177) = &input.password {
object.key("Password").string(var_177.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_voice_connector_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VoiceConnectorSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_178) = &input.cdr_bucket {
object.key("CdrBucket").string(var_178.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_dnis_emergency_calling_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DnisEmergencyCallingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_179) = &input.emergency_phone_number {
object.key("EmergencyPhoneNumber").string(var_179.as_str());
}
if let Some(var_180) = &input.test_phone_number {
object.key("TestPhoneNumber").string(var_180.as_str());
}
if let Some(var_181) = &input.calling_country {
object.key("CallingCountry").string(var_181.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_origination_route(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OriginationRoute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_182) = &input.host {
object.key("Host").string(var_182.as_str());
}
if let Some(var_183) = &input.port {
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_183).into()),
);
}
if let Some(var_184) = &input.protocol {
object.key("Protocol").string(var_184.as_str());
}
if let Some(var_185) = &input.priority {
object.key("Priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_185).into()),
);
}
if let Some(var_186) = &input.weight {
object.key("Weight").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_186).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_streaming_notification_target(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StreamingNotificationTarget,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_187) = &input.notification_target {
object.key("NotificationTarget").string(var_187.as_str());
}
Ok(())
}