pub fn serialize_structure_crate_input_associate_approved_origin_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateApprovedOriginInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.origin {
object.key("Origin").string(var_1.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_bot_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateBotInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2) = &input.lex_bot {
#[allow(unused_mut)]
let mut object_3 = object.key("LexBot").start_object();
crate::json_ser::serialize_structure_crate_model_lex_bot(&mut object_3, var_2)?;
object_3.finish();
}
if let Some(var_4) = &input.lex_v2_bot {
#[allow(unused_mut)]
let mut object_5 = object.key("LexV2Bot").start_object();
crate::json_ser::serialize_structure_crate_model_lex_v2_bot(&mut object_5, var_4)?;
object_5.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_default_vocabulary_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateDefaultVocabularyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_6) = &input.vocabulary_id {
object.key("VocabularyId").string(var_6.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_instance_storage_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateInstanceStorageConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_7) = &input.resource_type {
object.key("ResourceType").string(var_7.as_str());
}
if let Some(var_8) = &input.storage_config {
#[allow(unused_mut)]
let mut object_9 = object.key("StorageConfig").start_object();
crate::json_ser::serialize_structure_crate_model_instance_storage_config(
&mut object_9,
var_8,
)?;
object_9.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_lambda_function_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateLambdaFunctionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_10) = &input.function_arn {
object.key("FunctionArn").string(var_10.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_lex_bot_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateLexBotInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_11) = &input.lex_bot {
#[allow(unused_mut)]
let mut object_12 = object.key("LexBot").start_object();
crate::json_ser::serialize_structure_crate_model_lex_bot(&mut object_12, var_11)?;
object_12.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_phone_number_contact_flow_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociatePhoneNumberContactFlowInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_13) = &input.contact_flow_id {
object.key("ContactFlowId").string(var_13.as_str());
}
if let Some(var_14) = &input.instance_id {
object.key("InstanceId").string(var_14.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_queue_quick_connects_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateQueueQuickConnectsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_15) = &input.quick_connect_ids {
let mut array_16 = object.key("QuickConnectIds").start_array();
for item_17 in var_15 {
{
array_16.value().string(item_17.as_str());
}
}
array_16.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_routing_profile_queues_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateRoutingProfileQueuesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_18) = &input.queue_configs {
let mut array_19 = object.key("QueueConfigs").start_array();
for item_20 in var_18 {
{
#[allow(unused_mut)]
let mut object_21 = array_19.value().start_object();
crate::json_ser::serialize_structure_crate_model_routing_profile_queue_config(
&mut object_21,
item_20,
)?;
object_21.finish();
}
}
array_19.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_security_key_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateSecurityKeyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_22) = &input.key {
object.key("Key").string(var_22.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_claim_phone_number_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ClaimPhoneNumberInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_23) = &input.client_token {
object.key("ClientToken").string(var_23.as_str());
}
if let Some(var_24) = &input.phone_number {
object.key("PhoneNumber").string(var_24.as_str());
}
if let Some(var_25) = &input.phone_number_description {
object.key("PhoneNumberDescription").string(var_25.as_str());
}
if let Some(var_26) = &input.tags {
#[allow(unused_mut)]
let mut object_27 = object.key("Tags").start_object();
for (key_28, value_29) in var_26 {
{
object_27.key(key_28.as_str()).string(value_29.as_str());
}
}
object_27.finish();
}
if let Some(var_30) = &input.target_arn {
object.key("TargetArn").string(var_30.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_agent_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAgentStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_31) = &input.description {
object.key("Description").string(var_31.as_str());
}
if let Some(var_32) = &input.display_order {
object.key("DisplayOrder").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_32).into()),
);
}
if let Some(var_33) = &input.name {
object.key("Name").string(var_33.as_str());
}
if let Some(var_34) = &input.state {
object.key("State").string(var_34.as_str());
}
if let Some(var_35) = &input.tags {
#[allow(unused_mut)]
let mut object_36 = object.key("Tags").start_object();
for (key_37, value_38) in var_35 {
{
object_36.key(key_37.as_str()).string(value_38.as_str());
}
}
object_36.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_contact_flow_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateContactFlowInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_39) = &input.content {
object.key("Content").string(var_39.as_str());
}
if let Some(var_40) = &input.description {
object.key("Description").string(var_40.as_str());
}
if let Some(var_41) = &input.name {
object.key("Name").string(var_41.as_str());
}
if let Some(var_42) = &input.tags {
#[allow(unused_mut)]
let mut object_43 = object.key("Tags").start_object();
for (key_44, value_45) in var_42 {
{
object_43.key(key_44.as_str()).string(value_45.as_str());
}
}
object_43.finish();
}
if let Some(var_46) = &input.r#type {
object.key("Type").string(var_46.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_contact_flow_module_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateContactFlowModuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_47) = &input.client_token {
object.key("ClientToken").string(var_47.as_str());
}
if let Some(var_48) = &input.content {
object.key("Content").string(var_48.as_str());
}
if let Some(var_49) = &input.description {
object.key("Description").string(var_49.as_str());
}
if let Some(var_50) = &input.name {
object.key("Name").string(var_50.as_str());
}
if let Some(var_51) = &input.tags {
#[allow(unused_mut)]
let mut object_52 = object.key("Tags").start_object();
for (key_53, value_54) in var_51 {
{
object_52.key(key_53.as_str()).string(value_54.as_str());
}
}
object_52.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_hours_of_operation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateHoursOfOperationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_55) = &input.config {
let mut array_56 = object.key("Config").start_array();
for item_57 in var_55 {
{
#[allow(unused_mut)]
let mut object_58 = array_56.value().start_object();
crate::json_ser::serialize_structure_crate_model_hours_of_operation_config(
&mut object_58,
item_57,
)?;
object_58.finish();
}
}
array_56.finish();
}
if let Some(var_59) = &input.description {
object.key("Description").string(var_59.as_str());
}
if let Some(var_60) = &input.name {
object.key("Name").string(var_60.as_str());
}
if let Some(var_61) = &input.tags {
#[allow(unused_mut)]
let mut object_62 = object.key("Tags").start_object();
for (key_63, value_64) in var_61 {
{
object_62.key(key_63.as_str()).string(value_64.as_str());
}
}
object_62.finish();
}
if let Some(var_65) = &input.time_zone {
object.key("TimeZone").string(var_65.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_instance_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateInstanceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_66) = &input.client_token {
object.key("ClientToken").string(var_66.as_str());
}
if let Some(var_67) = &input.directory_id {
object.key("DirectoryId").string(var_67.as_str());
}
if let Some(var_68) = &input.identity_management_type {
object.key("IdentityManagementType").string(var_68.as_str());
}
if let Some(var_69) = &input.inbound_calls_enabled {
object.key("InboundCallsEnabled").boolean(*var_69);
}
if let Some(var_70) = &input.instance_alias {
object.key("InstanceAlias").string(var_70.as_str());
}
if let Some(var_71) = &input.outbound_calls_enabled {
object.key("OutboundCallsEnabled").boolean(*var_71);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_integration_association_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateIntegrationAssociationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_72) = &input.integration_arn {
object.key("IntegrationArn").string(var_72.as_str());
}
if let Some(var_73) = &input.integration_type {
object.key("IntegrationType").string(var_73.as_str());
}
if let Some(var_74) = &input.source_application_name {
object.key("SourceApplicationName").string(var_74.as_str());
}
if let Some(var_75) = &input.source_application_url {
object.key("SourceApplicationUrl").string(var_75.as_str());
}
if let Some(var_76) = &input.source_type {
object.key("SourceType").string(var_76.as_str());
}
if let Some(var_77) = &input.tags {
#[allow(unused_mut)]
let mut object_78 = object.key("Tags").start_object();
for (key_79, value_80) in var_77 {
{
object_78.key(key_79.as_str()).string(value_80.as_str());
}
}
object_78.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_queue_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateQueueInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_81) = &input.description {
object.key("Description").string(var_81.as_str());
}
if let Some(var_82) = &input.hours_of_operation_id {
object.key("HoursOfOperationId").string(var_82.as_str());
}
if let Some(var_83) = &input.max_contacts {
object.key("MaxContacts").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_83).into()),
);
}
if let Some(var_84) = &input.name {
object.key("Name").string(var_84.as_str());
}
if let Some(var_85) = &input.outbound_caller_config {
#[allow(unused_mut)]
let mut object_86 = object.key("OutboundCallerConfig").start_object();
crate::json_ser::serialize_structure_crate_model_outbound_caller_config(
&mut object_86,
var_85,
)?;
object_86.finish();
}
if let Some(var_87) = &input.quick_connect_ids {
let mut array_88 = object.key("QuickConnectIds").start_array();
for item_89 in var_87 {
{
array_88.value().string(item_89.as_str());
}
}
array_88.finish();
}
if let Some(var_90) = &input.tags {
#[allow(unused_mut)]
let mut object_91 = object.key("Tags").start_object();
for (key_92, value_93) in var_90 {
{
object_91.key(key_92.as_str()).string(value_93.as_str());
}
}
object_91.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_quick_connect_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateQuickConnectInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_94) = &input.description {
object.key("Description").string(var_94.as_str());
}
if let Some(var_95) = &input.name {
object.key("Name").string(var_95.as_str());
}
if let Some(var_96) = &input.quick_connect_config {
#[allow(unused_mut)]
let mut object_97 = object.key("QuickConnectConfig").start_object();
crate::json_ser::serialize_structure_crate_model_quick_connect_config(
&mut object_97,
var_96,
)?;
object_97.finish();
}
if let Some(var_98) = &input.tags {
#[allow(unused_mut)]
let mut object_99 = object.key("Tags").start_object();
for (key_100, value_101) in var_98 {
{
object_99.key(key_100.as_str()).string(value_101.as_str());
}
}
object_99.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_routing_profile_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateRoutingProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_102) = &input.default_outbound_queue_id {
object
.key("DefaultOutboundQueueId")
.string(var_102.as_str());
}
if let Some(var_103) = &input.description {
object.key("Description").string(var_103.as_str());
}
if let Some(var_104) = &input.media_concurrencies {
let mut array_105 = object.key("MediaConcurrencies").start_array();
for item_106 in var_104 {
{
#[allow(unused_mut)]
let mut object_107 = array_105.value().start_object();
crate::json_ser::serialize_structure_crate_model_media_concurrency(
&mut object_107,
item_106,
)?;
object_107.finish();
}
}
array_105.finish();
}
if let Some(var_108) = &input.name {
object.key("Name").string(var_108.as_str());
}
if let Some(var_109) = &input.queue_configs {
let mut array_110 = object.key("QueueConfigs").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_routing_profile_queue_config(
&mut object_112,
item_111,
)?;
object_112.finish();
}
}
array_110.finish();
}
if let Some(var_113) = &input.tags {
#[allow(unused_mut)]
let mut object_114 = object.key("Tags").start_object();
for (key_115, value_116) in var_113 {
{
object_114.key(key_115.as_str()).string(value_116.as_str());
}
}
object_114.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_117) = &input.actions {
let mut array_118 = object.key("Actions").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_rule_action(
&mut object_120,
item_119,
)?;
object_120.finish();
}
}
array_118.finish();
}
if let Some(var_121) = &input.client_token {
object.key("ClientToken").string(var_121.as_str());
}
if let Some(var_122) = &input.function {
object.key("Function").string(var_122.as_str());
}
if let Some(var_123) = &input.name {
object.key("Name").string(var_123.as_str());
}
if let Some(var_124) = &input.publish_status {
object.key("PublishStatus").string(var_124.as_str());
}
if let Some(var_125) = &input.trigger_event_source {
#[allow(unused_mut)]
let mut object_126 = object.key("TriggerEventSource").start_object();
crate::json_ser::serialize_structure_crate_model_rule_trigger_event_source(
&mut object_126,
var_125,
)?;
object_126.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_security_profile_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSecurityProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_127) = &input.allowed_access_control_tags {
#[allow(unused_mut)]
let mut object_128 = object.key("AllowedAccessControlTags").start_object();
for (key_129, value_130) in var_127 {
{
object_128.key(key_129.as_str()).string(value_130.as_str());
}
}
object_128.finish();
}
if let Some(var_131) = &input.description {
object.key("Description").string(var_131.as_str());
}
if let Some(var_132) = &input.permissions {
let mut array_133 = object.key("Permissions").start_array();
for item_134 in var_132 {
{
array_133.value().string(item_134.as_str());
}
}
array_133.finish();
}
if let Some(var_135) = &input.security_profile_name {
object.key("SecurityProfileName").string(var_135.as_str());
}
if let Some(var_136) = &input.tag_restricted_resources {
let mut array_137 = object.key("TagRestrictedResources").start_array();
for item_138 in var_136 {
{
array_137.value().string(item_138.as_str());
}
}
array_137.finish();
}
if let Some(var_139) = &input.tags {
#[allow(unused_mut)]
let mut object_140 = object.key("Tags").start_object();
for (key_141, value_142) in var_139 {
{
object_140.key(key_141.as_str()).string(value_142.as_str());
}
}
object_140.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_task_template_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateTaskTemplateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_143) = &input.client_token {
object.key("ClientToken").string(var_143.as_str());
}
if let Some(var_144) = &input.constraints {
#[allow(unused_mut)]
let mut object_145 = object.key("Constraints").start_object();
crate::json_ser::serialize_structure_crate_model_task_template_constraints(
&mut object_145,
var_144,
)?;
object_145.finish();
}
if let Some(var_146) = &input.contact_flow_id {
object.key("ContactFlowId").string(var_146.as_str());
}
if let Some(var_147) = &input.defaults {
#[allow(unused_mut)]
let mut object_148 = object.key("Defaults").start_object();
crate::json_ser::serialize_structure_crate_model_task_template_defaults(
&mut object_148,
var_147,
)?;
object_148.finish();
}
if let Some(var_149) = &input.description {
object.key("Description").string(var_149.as_str());
}
if let Some(var_150) = &input.fields {
let mut array_151 = object.key("Fields").start_array();
for item_152 in var_150 {
{
#[allow(unused_mut)]
let mut object_153 = array_151.value().start_object();
crate::json_ser::serialize_structure_crate_model_task_template_field(
&mut object_153,
item_152,
)?;
object_153.finish();
}
}
array_151.finish();
}
if let Some(var_154) = &input.name {
object.key("Name").string(var_154.as_str());
}
if let Some(var_155) = &input.status {
object.key("Status").string(var_155.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_traffic_distribution_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateTrafficDistributionGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_156) = &input.client_token {
object.key("ClientToken").string(var_156.as_str());
}
if let Some(var_157) = &input.description {
object.key("Description").string(var_157.as_str());
}
if let Some(var_158) = &input.instance_id {
object.key("InstanceId").string(var_158.as_str());
}
if let Some(var_159) = &input.name {
object.key("Name").string(var_159.as_str());
}
if let Some(var_160) = &input.tags {
#[allow(unused_mut)]
let mut object_161 = object.key("Tags").start_object();
for (key_162, value_163) in var_160 {
{
object_161.key(key_162.as_str()).string(value_163.as_str());
}
}
object_161.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_use_case_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateUseCaseInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_164) = &input.tags {
#[allow(unused_mut)]
let mut object_165 = object.key("Tags").start_object();
for (key_166, value_167) in var_164 {
{
object_165.key(key_166.as_str()).string(value_167.as_str());
}
}
object_165.finish();
}
if let Some(var_168) = &input.use_case_type {
object.key("UseCaseType").string(var_168.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_user_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateUserInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_169) = &input.directory_user_id {
object.key("DirectoryUserId").string(var_169.as_str());
}
if let Some(var_170) = &input.hierarchy_group_id {
object.key("HierarchyGroupId").string(var_170.as_str());
}
if let Some(var_171) = &input.identity_info {
#[allow(unused_mut)]
let mut object_172 = object.key("IdentityInfo").start_object();
crate::json_ser::serialize_structure_crate_model_user_identity_info(
&mut object_172,
var_171,
)?;
object_172.finish();
}
if let Some(var_173) = &input.password {
object.key("Password").string(var_173.as_str());
}
if let Some(var_174) = &input.phone_config {
#[allow(unused_mut)]
let mut object_175 = object.key("PhoneConfig").start_object();
crate::json_ser::serialize_structure_crate_model_user_phone_config(
&mut object_175,
var_174,
)?;
object_175.finish();
}
if let Some(var_176) = &input.routing_profile_id {
object.key("RoutingProfileId").string(var_176.as_str());
}
if let Some(var_177) = &input.security_profile_ids {
let mut array_178 = object.key("SecurityProfileIds").start_array();
for item_179 in var_177 {
{
array_178.value().string(item_179.as_str());
}
}
array_178.finish();
}
if let Some(var_180) = &input.tags {
#[allow(unused_mut)]
let mut object_181 = object.key("Tags").start_object();
for (key_182, value_183) in var_180 {
{
object_181.key(key_182.as_str()).string(value_183.as_str());
}
}
object_181.finish();
}
if let Some(var_184) = &input.username {
object.key("Username").string(var_184.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_user_hierarchy_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateUserHierarchyGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_185) = &input.name {
object.key("Name").string(var_185.as_str());
}
if let Some(var_186) = &input.parent_group_id {
object.key("ParentGroupId").string(var_186.as_str());
}
if let Some(var_187) = &input.tags {
#[allow(unused_mut)]
let mut object_188 = object.key("Tags").start_object();
for (key_189, value_190) in var_187 {
{
object_188.key(key_189.as_str()).string(value_190.as_str());
}
}
object_188.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_vocabulary_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateVocabularyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_191) = &input.client_token {
object.key("ClientToken").string(var_191.as_str());
}
if let Some(var_192) = &input.content {
object.key("Content").string(var_192.as_str());
}
if let Some(var_193) = &input.language_code {
object.key("LanguageCode").string(var_193.as_str());
}
if let Some(var_194) = &input.tags {
#[allow(unused_mut)]
let mut object_195 = object.key("Tags").start_object();
for (key_196, value_197) in var_194 {
{
object_195.key(key_196.as_str()).string(value_197.as_str());
}
}
object_195.finish();
}
if let Some(var_198) = &input.vocabulary_name {
object.key("VocabularyName").string(var_198.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_bot_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateBotInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_199) = &input.lex_bot {
#[allow(unused_mut)]
let mut object_200 = object.key("LexBot").start_object();
crate::json_ser::serialize_structure_crate_model_lex_bot(&mut object_200, var_199)?;
object_200.finish();
}
if let Some(var_201) = &input.lex_v2_bot {
#[allow(unused_mut)]
let mut object_202 = object.key("LexV2Bot").start_object();
crate::json_ser::serialize_structure_crate_model_lex_v2_bot(&mut object_202, var_201)?;
object_202.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_queue_quick_connects_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateQueueQuickConnectsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_203) = &input.quick_connect_ids {
let mut array_204 = object.key("QuickConnectIds").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_disassociate_routing_profile_queues_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateRoutingProfileQueuesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_206) = &input.queue_references {
let mut array_207 = object.key("QueueReferences").start_array();
for item_208 in var_206 {
{
#[allow(unused_mut)]
let mut object_209 = array_207.value().start_object();
crate::json_ser::serialize_structure_crate_model_routing_profile_queue_reference(
&mut object_209,
item_208,
)?;
object_209.finish();
}
}
array_207.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_dismiss_user_contact_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DismissUserContactInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_210) = &input.contact_id {
object.key("ContactId").string(var_210.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_current_metric_data_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetCurrentMetricDataInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_211) = &input.current_metrics {
let mut array_212 = object.key("CurrentMetrics").start_array();
for item_213 in var_211 {
{
#[allow(unused_mut)]
let mut object_214 = array_212.value().start_object();
crate::json_ser::serialize_structure_crate_model_current_metric(
&mut object_214,
item_213,
)?;
object_214.finish();
}
}
array_212.finish();
}
if let Some(var_215) = &input.filters {
#[allow(unused_mut)]
let mut object_216 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_filters(&mut object_216, var_215)?;
object_216.finish();
}
if let Some(var_217) = &input.groupings {
let mut array_218 = object.key("Groupings").start_array();
for item_219 in var_217 {
{
array_218.value().string(item_219.as_str());
}
}
array_218.finish();
}
if let Some(var_220) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_220).into()),
);
}
if let Some(var_221) = &input.next_token {
object.key("NextToken").string(var_221.as_str());
}
if let Some(var_222) = &input.sort_criteria {
let mut array_223 = object.key("SortCriteria").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_current_metric_sort_criteria(
&mut object_225,
item_224,
)?;
object_225.finish();
}
}
array_223.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_current_user_data_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetCurrentUserDataInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_226) = &input.filters {
#[allow(unused_mut)]
let mut object_227 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_user_data_filters(
&mut object_227,
var_226,
)?;
object_227.finish();
}
if let Some(var_228) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_228).into()),
);
}
if let Some(var_229) = &input.next_token {
object.key("NextToken").string(var_229.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_metric_data_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetMetricDataInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_230) = &input.end_time {
object
.key("EndTime")
.date_time(var_230, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_231) = &input.filters {
#[allow(unused_mut)]
let mut object_232 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_filters(&mut object_232, var_231)?;
object_232.finish();
}
if let Some(var_233) = &input.groupings {
let mut array_234 = object.key("Groupings").start_array();
for item_235 in var_233 {
{
array_234.value().string(item_235.as_str());
}
}
array_234.finish();
}
if let Some(var_236) = &input.historical_metrics {
let mut array_237 = object.key("HistoricalMetrics").start_array();
for item_238 in var_236 {
{
#[allow(unused_mut)]
let mut object_239 = array_237.value().start_object();
crate::json_ser::serialize_structure_crate_model_historical_metric(
&mut object_239,
item_238,
)?;
object_239.finish();
}
}
array_237.finish();
}
if let Some(var_240) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_240).into()),
);
}
if let Some(var_241) = &input.next_token {
object.key("NextToken").string(var_241.as_str());
}
if let Some(var_242) = &input.start_time {
object
.key("StartTime")
.date_time(var_242, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_input_list_default_vocabularies_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDefaultVocabulariesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_243) = &input.language_code {
object.key("LanguageCode").string(var_243.as_str());
}
if input.max_results != 0 {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_244) = &input.next_token {
object.key("NextToken").string(var_244.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_phone_numbers_v2_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListPhoneNumbersV2Input,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_245) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_245).into()),
);
}
if let Some(var_246) = &input.next_token {
object.key("NextToken").string(var_246.as_str());
}
if let Some(var_247) = &input.phone_number_country_codes {
let mut array_248 = object.key("PhoneNumberCountryCodes").start_array();
for item_249 in var_247 {
{
array_248.value().string(item_249.as_str());
}
}
array_248.finish();
}
if let Some(var_250) = &input.phone_number_prefix {
object.key("PhoneNumberPrefix").string(var_250.as_str());
}
if let Some(var_251) = &input.phone_number_types {
let mut array_252 = object.key("PhoneNumberTypes").start_array();
for item_253 in var_251 {
{
array_252.value().string(item_253.as_str());
}
}
array_252.finish();
}
if let Some(var_254) = &input.target_arn {
object.key("TargetArn").string(var_254.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_monitor_contact_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::MonitorContactInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_255) = &input.allowed_monitor_capabilities {
let mut array_256 = object.key("AllowedMonitorCapabilities").start_array();
for item_257 in var_255 {
{
array_256.value().string(item_257.as_str());
}
}
array_256.finish();
}
if let Some(var_258) = &input.client_token {
object.key("ClientToken").string(var_258.as_str());
}
if let Some(var_259) = &input.contact_id {
object.key("ContactId").string(var_259.as_str());
}
if let Some(var_260) = &input.instance_id {
object.key("InstanceId").string(var_260.as_str());
}
if let Some(var_261) = &input.user_id {
object.key("UserId").string(var_261.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_user_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutUserStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_262) = &input.agent_status_id {
object.key("AgentStatusId").string(var_262.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_replicate_instance_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ReplicateInstanceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_263) = &input.client_token {
object.key("ClientToken").string(var_263.as_str());
}
if let Some(var_264) = &input.replica_alias {
object.key("ReplicaAlias").string(var_264.as_str());
}
if let Some(var_265) = &input.replica_region {
object.key("ReplicaRegion").string(var_265.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_resume_contact_recording_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ResumeContactRecordingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_266) = &input.contact_id {
object.key("ContactId").string(var_266.as_str());
}
if let Some(var_267) = &input.initial_contact_id {
object.key("InitialContactId").string(var_267.as_str());
}
if let Some(var_268) = &input.instance_id {
object.key("InstanceId").string(var_268.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_search_available_phone_numbers_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchAvailablePhoneNumbersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_269) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_269).into()),
);
}
if let Some(var_270) = &input.next_token {
object.key("NextToken").string(var_270.as_str());
}
if let Some(var_271) = &input.phone_number_country_code {
object
.key("PhoneNumberCountryCode")
.string(var_271.as_str());
}
if let Some(var_272) = &input.phone_number_prefix {
object.key("PhoneNumberPrefix").string(var_272.as_str());
}
if let Some(var_273) = &input.phone_number_type {
object.key("PhoneNumberType").string(var_273.as_str());
}
if let Some(var_274) = &input.target_arn {
object.key("TargetArn").string(var_274.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_search_queues_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchQueuesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_275) = &input.instance_id {
object.key("InstanceId").string(var_275.as_str());
}
if let Some(var_276) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_276).into()),
);
}
if let Some(var_277) = &input.next_token {
object.key("NextToken").string(var_277.as_str());
}
if let Some(var_278) = &input.search_criteria {
#[allow(unused_mut)]
let mut object_279 = object.key("SearchCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_queue_search_criteria(
&mut object_279,
var_278,
)?;
object_279.finish();
}
if let Some(var_280) = &input.search_filter {
#[allow(unused_mut)]
let mut object_281 = object.key("SearchFilter").start_object();
crate::json_ser::serialize_structure_crate_model_queue_search_filter(
&mut object_281,
var_280,
)?;
object_281.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_search_routing_profiles_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchRoutingProfilesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_282) = &input.instance_id {
object.key("InstanceId").string(var_282.as_str());
}
if let Some(var_283) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_283).into()),
);
}
if let Some(var_284) = &input.next_token {
object.key("NextToken").string(var_284.as_str());
}
if let Some(var_285) = &input.search_criteria {
#[allow(unused_mut)]
let mut object_286 = object.key("SearchCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_routing_profile_search_criteria(
&mut object_286,
var_285,
)?;
object_286.finish();
}
if let Some(var_287) = &input.search_filter {
#[allow(unused_mut)]
let mut object_288 = object.key("SearchFilter").start_object();
crate::json_ser::serialize_structure_crate_model_routing_profile_search_filter(
&mut object_288,
var_287,
)?;
object_288.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_search_security_profiles_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchSecurityProfilesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_289) = &input.instance_id {
object.key("InstanceId").string(var_289.as_str());
}
if let Some(var_290) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_290).into()),
);
}
if let Some(var_291) = &input.next_token {
object.key("NextToken").string(var_291.as_str());
}
if let Some(var_292) = &input.search_criteria {
#[allow(unused_mut)]
let mut object_293 = object.key("SearchCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_security_profile_search_criteria(
&mut object_293,
var_292,
)?;
object_293.finish();
}
if let Some(var_294) = &input.search_filter {
#[allow(unused_mut)]
let mut object_295 = object.key("SearchFilter").start_object();
crate::json_ser::serialize_structure_crate_model_security_profiles_search_filter(
&mut object_295,
var_294,
)?;
object_295.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_296) = &input.instance_id {
object.key("InstanceId").string(var_296.as_str());
}
if let Some(var_297) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_297).into()),
);
}
if let Some(var_298) = &input.next_token {
object.key("NextToken").string(var_298.as_str());
}
if let Some(var_299) = &input.search_criteria {
#[allow(unused_mut)]
let mut object_300 = object.key("SearchCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_user_search_criteria(
&mut object_300,
var_299,
)?;
object_300.finish();
}
if let Some(var_301) = &input.search_filter {
#[allow(unused_mut)]
let mut object_302 = object.key("SearchFilter").start_object();
crate::json_ser::serialize_structure_crate_model_user_search_filter(
&mut object_302,
var_301,
)?;
object_302.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_search_vocabularies_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchVocabulariesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_303) = &input.language_code {
object.key("LanguageCode").string(var_303.as_str());
}
if input.max_results != 0 {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_304) = &input.name_starts_with {
object.key("NameStartsWith").string(var_304.as_str());
}
if let Some(var_305) = &input.next_token {
object.key("NextToken").string(var_305.as_str());
}
if let Some(var_306) = &input.state {
object.key("State").string(var_306.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_chat_contact_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartChatContactInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_307) = &input.attributes {
#[allow(unused_mut)]
let mut object_308 = object.key("Attributes").start_object();
for (key_309, value_310) in var_307 {
{
object_308.key(key_309.as_str()).string(value_310.as_str());
}
}
object_308.finish();
}
if let Some(var_311) = &input.chat_duration_in_minutes {
object.key("ChatDurationInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_311).into()),
);
}
if let Some(var_312) = &input.client_token {
object.key("ClientToken").string(var_312.as_str());
}
if let Some(var_313) = &input.contact_flow_id {
object.key("ContactFlowId").string(var_313.as_str());
}
if let Some(var_314) = &input.initial_message {
#[allow(unused_mut)]
let mut object_315 = object.key("InitialMessage").start_object();
crate::json_ser::serialize_structure_crate_model_chat_message(&mut object_315, var_314)?;
object_315.finish();
}
if let Some(var_316) = &input.instance_id {
object.key("InstanceId").string(var_316.as_str());
}
if let Some(var_317) = &input.participant_details {
#[allow(unused_mut)]
let mut object_318 = object.key("ParticipantDetails").start_object();
crate::json_ser::serialize_structure_crate_model_participant_details(
&mut object_318,
var_317,
)?;
object_318.finish();
}
if let Some(var_319) = &input.persistent_chat {
#[allow(unused_mut)]
let mut object_320 = object.key("PersistentChat").start_object();
crate::json_ser::serialize_structure_crate_model_persistent_chat(&mut object_320, var_319)?;
object_320.finish();
}
if let Some(var_321) = &input.supported_messaging_content_types {
let mut array_322 = object.key("SupportedMessagingContentTypes").start_array();
for item_323 in var_321 {
{
array_322.value().string(item_323.as_str());
}
}
array_322.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_contact_recording_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartContactRecordingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_324) = &input.contact_id {
object.key("ContactId").string(var_324.as_str());
}
if let Some(var_325) = &input.initial_contact_id {
object.key("InitialContactId").string(var_325.as_str());
}
if let Some(var_326) = &input.instance_id {
object.key("InstanceId").string(var_326.as_str());
}
if let Some(var_327) = &input.voice_recording_configuration {
#[allow(unused_mut)]
let mut object_328 = object.key("VoiceRecordingConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_voice_recording_configuration(
&mut object_328,
var_327,
)?;
object_328.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_contact_streaming_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartContactStreamingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_329) = &input.chat_streaming_configuration {
#[allow(unused_mut)]
let mut object_330 = object.key("ChatStreamingConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_chat_streaming_configuration(
&mut object_330,
var_329,
)?;
object_330.finish();
}
if let Some(var_331) = &input.client_token {
object.key("ClientToken").string(var_331.as_str());
}
if let Some(var_332) = &input.contact_id {
object.key("ContactId").string(var_332.as_str());
}
if let Some(var_333) = &input.instance_id {
object.key("InstanceId").string(var_333.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_outbound_voice_contact_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartOutboundVoiceContactInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_334) = &input.answer_machine_detection_config {
#[allow(unused_mut)]
let mut object_335 = object.key("AnswerMachineDetectionConfig").start_object();
crate::json_ser::serialize_structure_crate_model_answer_machine_detection_config(
&mut object_335,
var_334,
)?;
object_335.finish();
}
if let Some(var_336) = &input.attributes {
#[allow(unused_mut)]
let mut object_337 = object.key("Attributes").start_object();
for (key_338, value_339) in var_336 {
{
object_337.key(key_338.as_str()).string(value_339.as_str());
}
}
object_337.finish();
}
if let Some(var_340) = &input.campaign_id {
object.key("CampaignId").string(var_340.as_str());
}
if let Some(var_341) = &input.client_token {
object.key("ClientToken").string(var_341.as_str());
}
if let Some(var_342) = &input.contact_flow_id {
object.key("ContactFlowId").string(var_342.as_str());
}
if let Some(var_343) = &input.destination_phone_number {
object
.key("DestinationPhoneNumber")
.string(var_343.as_str());
}
if let Some(var_344) = &input.instance_id {
object.key("InstanceId").string(var_344.as_str());
}
if let Some(var_345) = &input.queue_id {
object.key("QueueId").string(var_345.as_str());
}
if let Some(var_346) = &input.source_phone_number {
object.key("SourcePhoneNumber").string(var_346.as_str());
}
if let Some(var_347) = &input.traffic_type {
object.key("TrafficType").string(var_347.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_task_contact_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartTaskContactInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_348) = &input.attributes {
#[allow(unused_mut)]
let mut object_349 = object.key("Attributes").start_object();
for (key_350, value_351) in var_348 {
{
object_349.key(key_350.as_str()).string(value_351.as_str());
}
}
object_349.finish();
}
if let Some(var_352) = &input.client_token {
object.key("ClientToken").string(var_352.as_str());
}
if let Some(var_353) = &input.contact_flow_id {
object.key("ContactFlowId").string(var_353.as_str());
}
if let Some(var_354) = &input.description {
object.key("Description").string(var_354.as_str());
}
if let Some(var_355) = &input.instance_id {
object.key("InstanceId").string(var_355.as_str());
}
if let Some(var_356) = &input.name {
object.key("Name").string(var_356.as_str());
}
if let Some(var_357) = &input.previous_contact_id {
object.key("PreviousContactId").string(var_357.as_str());
}
if let Some(var_358) = &input.quick_connect_id {
object.key("QuickConnectId").string(var_358.as_str());
}
if let Some(var_359) = &input.references {
#[allow(unused_mut)]
let mut object_360 = object.key("References").start_object();
for (key_361, value_362) in var_359 {
{
#[allow(unused_mut)]
let mut object_363 = object_360.key(key_361.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_reference(
&mut object_363,
value_362,
)?;
object_363.finish();
}
}
object_360.finish();
}
if let Some(var_364) = &input.scheduled_time {
object
.key("ScheduledTime")
.date_time(var_364, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_365) = &input.task_template_id {
object.key("TaskTemplateId").string(var_365.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_contact_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopContactInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_366) = &input.contact_id {
object.key("ContactId").string(var_366.as_str());
}
if let Some(var_367) = &input.instance_id {
object.key("InstanceId").string(var_367.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_contact_recording_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopContactRecordingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_368) = &input.contact_id {
object.key("ContactId").string(var_368.as_str());
}
if let Some(var_369) = &input.initial_contact_id {
object.key("InitialContactId").string(var_369.as_str());
}
if let Some(var_370) = &input.instance_id {
object.key("InstanceId").string(var_370.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_contact_streaming_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopContactStreamingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_371) = &input.contact_id {
object.key("ContactId").string(var_371.as_str());
}
if let Some(var_372) = &input.instance_id {
object.key("InstanceId").string(var_372.as_str());
}
if let Some(var_373) = &input.streaming_id {
object.key("StreamingId").string(var_373.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_suspend_contact_recording_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SuspendContactRecordingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_374) = &input.contact_id {
object.key("ContactId").string(var_374.as_str());
}
if let Some(var_375) = &input.initial_contact_id {
object.key("InitialContactId").string(var_375.as_str());
}
if let Some(var_376) = &input.instance_id {
object.key("InstanceId").string(var_376.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_377) = &input.tags {
#[allow(unused_mut)]
let mut object_378 = object.key("tags").start_object();
for (key_379, value_380) in var_377 {
{
object_378.key(key_379.as_str()).string(value_380.as_str());
}
}
object_378.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_transfer_contact_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TransferContactInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_381) = &input.client_token {
object.key("ClientToken").string(var_381.as_str());
}
if let Some(var_382) = &input.contact_flow_id {
object.key("ContactFlowId").string(var_382.as_str());
}
if let Some(var_383) = &input.contact_id {
object.key("ContactId").string(var_383.as_str());
}
if let Some(var_384) = &input.instance_id {
object.key("InstanceId").string(var_384.as_str());
}
if let Some(var_385) = &input.queue_id {
object.key("QueueId").string(var_385.as_str());
}
if let Some(var_386) = &input.user_id {
object.key("UserId").string(var_386.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_agent_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAgentStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_387) = &input.description {
object.key("Description").string(var_387.as_str());
}
if let Some(var_388) = &input.display_order {
object.key("DisplayOrder").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_388).into()),
);
}
if let Some(var_389) = &input.name {
object.key("Name").string(var_389.as_str());
}
if input.reset_order_number {
object
.key("ResetOrderNumber")
.boolean(input.reset_order_number);
}
if let Some(var_390) = &input.state {
object.key("State").string(var_390.as_str());
}
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_391) = &input.description {
object.key("Description").string(var_391.as_str());
}
if let Some(var_392) = &input.name {
object.key("Name").string(var_392.as_str());
}
if let Some(var_393) = &input.references {
#[allow(unused_mut)]
let mut object_394 = object.key("References").start_object();
for (key_395, value_396) in var_393 {
{
#[allow(unused_mut)]
let mut object_397 = object_394.key(key_395.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_reference(
&mut object_397,
value_396,
)?;
object_397.finish();
}
}
object_394.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_contact_attributes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateContactAttributesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_398) = &input.attributes {
#[allow(unused_mut)]
let mut object_399 = object.key("Attributes").start_object();
for (key_400, value_401) in var_398 {
{
object_399.key(key_400.as_str()).string(value_401.as_str());
}
}
object_399.finish();
}
if let Some(var_402) = &input.initial_contact_id {
object.key("InitialContactId").string(var_402.as_str());
}
if let Some(var_403) = &input.instance_id {
object.key("InstanceId").string(var_403.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_contact_flow_content_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateContactFlowContentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_404) = &input.content {
object.key("Content").string(var_404.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_contact_flow_metadata_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateContactFlowMetadataInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_405) = &input.contact_flow_state {
object.key("ContactFlowState").string(var_405.as_str());
}
if let Some(var_406) = &input.description {
object.key("Description").string(var_406.as_str());
}
if let Some(var_407) = &input.name {
object.key("Name").string(var_407.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_contact_flow_module_content_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateContactFlowModuleContentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_408) = &input.content {
object.key("Content").string(var_408.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_contact_flow_module_metadata_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateContactFlowModuleMetadataInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_409) = &input.description {
object.key("Description").string(var_409.as_str());
}
if let Some(var_410) = &input.name {
object.key("Name").string(var_410.as_str());
}
if let Some(var_411) = &input.state {
object.key("State").string(var_411.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_contact_flow_name_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateContactFlowNameInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_412) = &input.description {
object.key("Description").string(var_412.as_str());
}
if let Some(var_413) = &input.name {
object.key("Name").string(var_413.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_contact_schedule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateContactScheduleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_414) = &input.contact_id {
object.key("ContactId").string(var_414.as_str());
}
if let Some(var_415) = &input.instance_id {
object.key("InstanceId").string(var_415.as_str());
}
if let Some(var_416) = &input.scheduled_time {
object
.key("ScheduledTime")
.date_time(var_416, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_input_update_hours_of_operation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateHoursOfOperationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_417) = &input.config {
let mut array_418 = object.key("Config").start_array();
for item_419 in var_417 {
{
#[allow(unused_mut)]
let mut object_420 = array_418.value().start_object();
crate::json_ser::serialize_structure_crate_model_hours_of_operation_config(
&mut object_420,
item_419,
)?;
object_420.finish();
}
}
array_418.finish();
}
if let Some(var_421) = &input.description {
object.key("Description").string(var_421.as_str());
}
if let Some(var_422) = &input.name {
object.key("Name").string(var_422.as_str());
}
if let Some(var_423) = &input.time_zone {
object.key("TimeZone").string(var_423.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_instance_attribute_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateInstanceAttributeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_424) = &input.value {
object.key("Value").string(var_424.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_instance_storage_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateInstanceStorageConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_425) = &input.storage_config {
#[allow(unused_mut)]
let mut object_426 = object.key("StorageConfig").start_object();
crate::json_ser::serialize_structure_crate_model_instance_storage_config(
&mut object_426,
var_425,
)?;
object_426.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_participant_role_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateParticipantRoleConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_427) = &input.channel_configuration {
#[allow(unused_mut)]
let mut object_428 = object.key("ChannelConfiguration").start_object();
crate::json_ser::serialize_union_crate_model_update_participant_role_config_channel_info(
&mut object_428,
var_427,
)?;
object_428.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_429) = &input.client_token {
object.key("ClientToken").string(var_429.as_str());
}
if let Some(var_430) = &input.target_arn {
object.key("TargetArn").string(var_430.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_queue_hours_of_operation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateQueueHoursOfOperationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_431) = &input.hours_of_operation_id {
object.key("HoursOfOperationId").string(var_431.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_queue_max_contacts_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateQueueMaxContactsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_432) = &input.max_contacts {
object.key("MaxContacts").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_432).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_queue_name_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateQueueNameInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_433) = &input.description {
object.key("Description").string(var_433.as_str());
}
if let Some(var_434) = &input.name {
object.key("Name").string(var_434.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_queue_outbound_caller_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateQueueOutboundCallerConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_435) = &input.outbound_caller_config {
#[allow(unused_mut)]
let mut object_436 = object.key("OutboundCallerConfig").start_object();
crate::json_ser::serialize_structure_crate_model_outbound_caller_config(
&mut object_436,
var_435,
)?;
object_436.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_queue_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateQueueStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_437) = &input.status {
object.key("Status").string(var_437.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_quick_connect_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateQuickConnectConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_438) = &input.quick_connect_config {
#[allow(unused_mut)]
let mut object_439 = object.key("QuickConnectConfig").start_object();
crate::json_ser::serialize_structure_crate_model_quick_connect_config(
&mut object_439,
var_438,
)?;
object_439.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_quick_connect_name_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateQuickConnectNameInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_440) = &input.description {
object.key("Description").string(var_440.as_str());
}
if let Some(var_441) = &input.name {
object.key("Name").string(var_441.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_routing_profile_concurrency_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRoutingProfileConcurrencyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_442) = &input.media_concurrencies {
let mut array_443 = object.key("MediaConcurrencies").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_media_concurrency(
&mut object_445,
item_444,
)?;
object_445.finish();
}
}
array_443.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_routing_profile_default_outbound_queue_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRoutingProfileDefaultOutboundQueueInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_446) = &input.default_outbound_queue_id {
object
.key("DefaultOutboundQueueId")
.string(var_446.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_routing_profile_name_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRoutingProfileNameInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_447) = &input.description {
object.key("Description").string(var_447.as_str());
}
if let Some(var_448) = &input.name {
object.key("Name").string(var_448.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_routing_profile_queues_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRoutingProfileQueuesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_449) = &input.queue_configs {
let mut array_450 = object.key("QueueConfigs").start_array();
for item_451 in var_449 {
{
#[allow(unused_mut)]
let mut object_452 = array_450.value().start_object();
crate::json_ser::serialize_structure_crate_model_routing_profile_queue_config(
&mut object_452,
item_451,
)?;
object_452.finish();
}
}
array_450.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_453) = &input.actions {
let mut array_454 = object.key("Actions").start_array();
for item_455 in var_453 {
{
#[allow(unused_mut)]
let mut object_456 = array_454.value().start_object();
crate::json_ser::serialize_structure_crate_model_rule_action(
&mut object_456,
item_455,
)?;
object_456.finish();
}
}
array_454.finish();
}
if let Some(var_457) = &input.function {
object.key("Function").string(var_457.as_str());
}
if let Some(var_458) = &input.name {
object.key("Name").string(var_458.as_str());
}
if let Some(var_459) = &input.publish_status {
object.key("PublishStatus").string(var_459.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_security_profile_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSecurityProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_460) = &input.allowed_access_control_tags {
#[allow(unused_mut)]
let mut object_461 = object.key("AllowedAccessControlTags").start_object();
for (key_462, value_463) in var_460 {
{
object_461.key(key_462.as_str()).string(value_463.as_str());
}
}
object_461.finish();
}
if let Some(var_464) = &input.description {
object.key("Description").string(var_464.as_str());
}
if let Some(var_465) = &input.permissions {
let mut array_466 = object.key("Permissions").start_array();
for item_467 in var_465 {
{
array_466.value().string(item_467.as_str());
}
}
array_466.finish();
}
if let Some(var_468) = &input.tag_restricted_resources {
let mut array_469 = object.key("TagRestrictedResources").start_array();
for item_470 in var_468 {
{
array_469.value().string(item_470.as_str());
}
}
array_469.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_task_template_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateTaskTemplateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_471) = &input.constraints {
#[allow(unused_mut)]
let mut object_472 = object.key("Constraints").start_object();
crate::json_ser::serialize_structure_crate_model_task_template_constraints(
&mut object_472,
var_471,
)?;
object_472.finish();
}
if let Some(var_473) = &input.contact_flow_id {
object.key("ContactFlowId").string(var_473.as_str());
}
if let Some(var_474) = &input.defaults {
#[allow(unused_mut)]
let mut object_475 = object.key("Defaults").start_object();
crate::json_ser::serialize_structure_crate_model_task_template_defaults(
&mut object_475,
var_474,
)?;
object_475.finish();
}
if let Some(var_476) = &input.description {
object.key("Description").string(var_476.as_str());
}
if let Some(var_477) = &input.fields {
let mut array_478 = object.key("Fields").start_array();
for item_479 in var_477 {
{
#[allow(unused_mut)]
let mut object_480 = array_478.value().start_object();
crate::json_ser::serialize_structure_crate_model_task_template_field(
&mut object_480,
item_479,
)?;
object_480.finish();
}
}
array_478.finish();
}
if let Some(var_481) = &input.name {
object.key("Name").string(var_481.as_str());
}
if let Some(var_482) = &input.status {
object.key("Status").string(var_482.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_traffic_distribution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateTrafficDistributionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_483) = &input.telephony_config {
#[allow(unused_mut)]
let mut object_484 = object.key("TelephonyConfig").start_object();
crate::json_ser::serialize_structure_crate_model_telephony_config(
&mut object_484,
var_483,
)?;
object_484.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_user_hierarchy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateUserHierarchyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_485) = &input.hierarchy_group_id {
object.key("HierarchyGroupId").string(var_485.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_user_hierarchy_group_name_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateUserHierarchyGroupNameInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_486) = &input.name {
object.key("Name").string(var_486.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_user_hierarchy_structure_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateUserHierarchyStructureInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_487) = &input.hierarchy_structure {
#[allow(unused_mut)]
let mut object_488 = object.key("HierarchyStructure").start_object();
crate::json_ser::serialize_structure_crate_model_hierarchy_structure_update(
&mut object_488,
var_487,
)?;
object_488.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_user_identity_info_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateUserIdentityInfoInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_489) = &input.identity_info {
#[allow(unused_mut)]
let mut object_490 = object.key("IdentityInfo").start_object();
crate::json_ser::serialize_structure_crate_model_user_identity_info(
&mut object_490,
var_489,
)?;
object_490.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_user_phone_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateUserPhoneConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_491) = &input.phone_config {
#[allow(unused_mut)]
let mut object_492 = object.key("PhoneConfig").start_object();
crate::json_ser::serialize_structure_crate_model_user_phone_config(
&mut object_492,
var_491,
)?;
object_492.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_user_routing_profile_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateUserRoutingProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_493) = &input.routing_profile_id {
object.key("RoutingProfileId").string(var_493.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_user_security_profiles_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateUserSecurityProfilesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_494) = &input.security_profile_ids {
let mut array_495 = object.key("SecurityProfileIds").start_array();
for item_496 in var_494 {
{
array_495.value().string(item_496.as_str());
}
}
array_495.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_lex_bot(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LexBot,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_497) = &input.name {
object.key("Name").string(var_497.as_str());
}
if let Some(var_498) = &input.lex_region {
object.key("LexRegion").string(var_498.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_lex_v2_bot(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LexV2Bot,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_499) = &input.alias_arn {
object.key("AliasArn").string(var_499.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_instance_storage_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InstanceStorageConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_500) = &input.association_id {
object.key("AssociationId").string(var_500.as_str());
}
if let Some(var_501) = &input.storage_type {
object.key("StorageType").string(var_501.as_str());
}
if let Some(var_502) = &input.s3_config {
#[allow(unused_mut)]
let mut object_503 = object.key("S3Config").start_object();
crate::json_ser::serialize_structure_crate_model_s3_config(&mut object_503, var_502)?;
object_503.finish();
}
if let Some(var_504) = &input.kinesis_video_stream_config {
#[allow(unused_mut)]
let mut object_505 = object.key("KinesisVideoStreamConfig").start_object();
crate::json_ser::serialize_structure_crate_model_kinesis_video_stream_config(
&mut object_505,
var_504,
)?;
object_505.finish();
}
if let Some(var_506) = &input.kinesis_stream_config {
#[allow(unused_mut)]
let mut object_507 = object.key("KinesisStreamConfig").start_object();
crate::json_ser::serialize_structure_crate_model_kinesis_stream_config(
&mut object_507,
var_506,
)?;
object_507.finish();
}
if let Some(var_508) = &input.kinesis_firehose_config {
#[allow(unused_mut)]
let mut object_509 = object.key("KinesisFirehoseConfig").start_object();
crate::json_ser::serialize_structure_crate_model_kinesis_firehose_config(
&mut object_509,
var_508,
)?;
object_509.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_routing_profile_queue_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RoutingProfileQueueConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_510) = &input.queue_reference {
#[allow(unused_mut)]
let mut object_511 = object.key("QueueReference").start_object();
crate::json_ser::serialize_structure_crate_model_routing_profile_queue_reference(
&mut object_511,
var_510,
)?;
object_511.finish();
}
if let Some(var_512) = &input.priority {
object.key("Priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_512).into()),
);
}
if let Some(var_513) = &input.delay {
object.key("Delay").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_513).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_hours_of_operation_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HoursOfOperationConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_514) = &input.day {
object.key("Day").string(var_514.as_str());
}
if let Some(var_515) = &input.start_time {
#[allow(unused_mut)]
let mut object_516 = object.key("StartTime").start_object();
crate::json_ser::serialize_structure_crate_model_hours_of_operation_time_slice(
&mut object_516,
var_515,
)?;
object_516.finish();
}
if let Some(var_517) = &input.end_time {
#[allow(unused_mut)]
let mut object_518 = object.key("EndTime").start_object();
crate::json_ser::serialize_structure_crate_model_hours_of_operation_time_slice(
&mut object_518,
var_517,
)?;
object_518.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_outbound_caller_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OutboundCallerConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_519) = &input.outbound_caller_id_name {
object.key("OutboundCallerIdName").string(var_519.as_str());
}
if let Some(var_520) = &input.outbound_caller_id_number_id {
object
.key("OutboundCallerIdNumberId")
.string(var_520.as_str());
}
if let Some(var_521) = &input.outbound_flow_id {
object.key("OutboundFlowId").string(var_521.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_quick_connect_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::QuickConnectConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_522) = &input.quick_connect_type {
object.key("QuickConnectType").string(var_522.as_str());
}
if let Some(var_523) = &input.user_config {
#[allow(unused_mut)]
let mut object_524 = object.key("UserConfig").start_object();
crate::json_ser::serialize_structure_crate_model_user_quick_connect_config(
&mut object_524,
var_523,
)?;
object_524.finish();
}
if let Some(var_525) = &input.queue_config {
#[allow(unused_mut)]
let mut object_526 = object.key("QueueConfig").start_object();
crate::json_ser::serialize_structure_crate_model_queue_quick_connect_config(
&mut object_526,
var_525,
)?;
object_526.finish();
}
if let Some(var_527) = &input.phone_config {
#[allow(unused_mut)]
let mut object_528 = object.key("PhoneConfig").start_object();
crate::json_ser::serialize_structure_crate_model_phone_number_quick_connect_config(
&mut object_528,
var_527,
)?;
object_528.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_media_concurrency(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MediaConcurrency,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_529) = &input.channel {
object.key("Channel").string(var_529.as_str());
}
{
object.key("Concurrency").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.concurrency).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_530) = &input.action_type {
object.key("ActionType").string(var_530.as_str());
}
if let Some(var_531) = &input.task_action {
#[allow(unused_mut)]
let mut object_532 = object.key("TaskAction").start_object();
crate::json_ser::serialize_structure_crate_model_task_action_definition(
&mut object_532,
var_531,
)?;
object_532.finish();
}
if let Some(var_533) = &input.event_bridge_action {
#[allow(unused_mut)]
let mut object_534 = object.key("EventBridgeAction").start_object();
crate::json_ser::serialize_structure_crate_model_event_bridge_action_definition(
&mut object_534,
var_533,
)?;
object_534.finish();
}
if let Some(var_535) = &input.assign_contact_category_action {
#[allow(unused_mut)]
let mut object_536 = object.key("AssignContactCategoryAction").start_object();
crate::json_ser::serialize_structure_crate_model_assign_contact_category_action_definition(
&mut object_536,
var_535,
)?;
object_536.finish();
}
if let Some(var_537) = &input.send_notification_action {
#[allow(unused_mut)]
let mut object_538 = object.key("SendNotificationAction").start_object();
crate::json_ser::serialize_structure_crate_model_send_notification_action_definition(
&mut object_538,
var_537,
)?;
object_538.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_trigger_event_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleTriggerEventSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_539) = &input.event_source_name {
object.key("EventSourceName").string(var_539.as_str());
}
if let Some(var_540) = &input.integration_association_id {
object
.key("IntegrationAssociationId")
.string(var_540.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_task_template_constraints(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TaskTemplateConstraints,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_541) = &input.required_fields {
let mut array_542 = object.key("RequiredFields").start_array();
for item_543 in var_541 {
{
#[allow(unused_mut)]
let mut object_544 = array_542.value().start_object();
crate::json_ser::serialize_structure_crate_model_required_field_info(
&mut object_544,
item_543,
)?;
object_544.finish();
}
}
array_542.finish();
}
if let Some(var_545) = &input.read_only_fields {
let mut array_546 = object.key("ReadOnlyFields").start_array();
for item_547 in var_545 {
{
#[allow(unused_mut)]
let mut object_548 = array_546.value().start_object();
crate::json_ser::serialize_structure_crate_model_read_only_field_info(
&mut object_548,
item_547,
)?;
object_548.finish();
}
}
array_546.finish();
}
if let Some(var_549) = &input.invisible_fields {
let mut array_550 = object.key("InvisibleFields").start_array();
for item_551 in var_549 {
{
#[allow(unused_mut)]
let mut object_552 = array_550.value().start_object();
crate::json_ser::serialize_structure_crate_model_invisible_field_info(
&mut object_552,
item_551,
)?;
object_552.finish();
}
}
array_550.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_task_template_defaults(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TaskTemplateDefaults,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_553) = &input.default_field_values {
let mut array_554 = object.key("DefaultFieldValues").start_array();
for item_555 in var_553 {
{
#[allow(unused_mut)]
let mut object_556 = array_554.value().start_object();
crate::json_ser::serialize_structure_crate_model_task_template_default_field_value(
&mut object_556,
item_555,
)?;
object_556.finish();
}
}
array_554.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_task_template_field(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TaskTemplateField,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_557) = &input.id {
#[allow(unused_mut)]
let mut object_558 = object.key("Id").start_object();
crate::json_ser::serialize_structure_crate_model_task_template_field_identifier(
&mut object_558,
var_557,
)?;
object_558.finish();
}
if let Some(var_559) = &input.description {
object.key("Description").string(var_559.as_str());
}
if let Some(var_560) = &input.r#type {
object.key("Type").string(var_560.as_str());
}
if let Some(var_561) = &input.single_select_options {
let mut array_562 = object.key("SingleSelectOptions").start_array();
for item_563 in var_561 {
{
array_562.value().string(item_563.as_str());
}
}
array_562.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_user_identity_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UserIdentityInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_564) = &input.first_name {
object.key("FirstName").string(var_564.as_str());
}
if let Some(var_565) = &input.last_name {
object.key("LastName").string(var_565.as_str());
}
if let Some(var_566) = &input.email {
object.key("Email").string(var_566.as_str());
}
if let Some(var_567) = &input.secondary_email {
object.key("SecondaryEmail").string(var_567.as_str());
}
if let Some(var_568) = &input.mobile {
object.key("Mobile").string(var_568.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_user_phone_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UserPhoneConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_569) = &input.phone_type {
object.key("PhoneType").string(var_569.as_str());
}
if input.auto_accept {
object.key("AutoAccept").boolean(input.auto_accept);
}
if input.after_contact_work_time_limit != 0 {
object.key("AfterContactWorkTimeLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.after_contact_work_time_limit).into()),
);
}
if let Some(var_570) = &input.desk_phone_number {
object.key("DeskPhoneNumber").string(var_570.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_routing_profile_queue_reference(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RoutingProfileQueueReference,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_571) = &input.queue_id {
object.key("QueueId").string(var_571.as_str());
}
if let Some(var_572) = &input.channel {
object.key("Channel").string(var_572.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_current_metric(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CurrentMetric,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_573) = &input.name {
object.key("Name").string(var_573.as_str());
}
if let Some(var_574) = &input.unit {
object.key("Unit").string(var_574.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Filters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_575) = &input.queues {
let mut array_576 = object.key("Queues").start_array();
for item_577 in var_575 {
{
array_576.value().string(item_577.as_str());
}
}
array_576.finish();
}
if let Some(var_578) = &input.channels {
let mut array_579 = object.key("Channels").start_array();
for item_580 in var_578 {
{
array_579.value().string(item_580.as_str());
}
}
array_579.finish();
}
if let Some(var_581) = &input.routing_profiles {
let mut array_582 = object.key("RoutingProfiles").start_array();
for item_583 in var_581 {
{
array_582.value().string(item_583.as_str());
}
}
array_582.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_current_metric_sort_criteria(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CurrentMetricSortCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_584) = &input.sort_by_metric {
object.key("SortByMetric").string(var_584.as_str());
}
if let Some(var_585) = &input.sort_order {
object.key("SortOrder").string(var_585.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_user_data_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UserDataFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_586) = &input.queues {
let mut array_587 = object.key("Queues").start_array();
for item_588 in var_586 {
{
array_587.value().string(item_588.as_str());
}
}
array_587.finish();
}
if let Some(var_589) = &input.contact_filter {
#[allow(unused_mut)]
let mut object_590 = object.key("ContactFilter").start_object();
crate::json_ser::serialize_structure_crate_model_contact_filter(&mut object_590, var_589)?;
object_590.finish();
}
if let Some(var_591) = &input.routing_profiles {
let mut array_592 = object.key("RoutingProfiles").start_array();
for item_593 in var_591 {
{
array_592.value().string(item_593.as_str());
}
}
array_592.finish();
}
if let Some(var_594) = &input.agents {
let mut array_595 = object.key("Agents").start_array();
for item_596 in var_594 {
{
array_595.value().string(item_596.as_str());
}
}
array_595.finish();
}
if let Some(var_597) = &input.user_hierarchy_groups {
let mut array_598 = object.key("UserHierarchyGroups").start_array();
for item_599 in var_597 {
{
array_598.value().string(item_599.as_str());
}
}
array_598.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_historical_metric(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HistoricalMetric,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_600) = &input.name {
object.key("Name").string(var_600.as_str());
}
if let Some(var_601) = &input.threshold {
#[allow(unused_mut)]
let mut object_602 = object.key("Threshold").start_object();
crate::json_ser::serialize_structure_crate_model_threshold(&mut object_602, var_601)?;
object_602.finish();
}
if let Some(var_603) = &input.statistic {
object.key("Statistic").string(var_603.as_str());
}
if let Some(var_604) = &input.unit {
object.key("Unit").string(var_604.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_queue_search_criteria(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::QueueSearchCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_605) = &input.or_conditions {
let mut array_606 = object.key("OrConditions").start_array();
for item_607 in var_605 {
{
#[allow(unused_mut)]
let mut object_608 = array_606.value().start_object();
crate::json_ser::serialize_structure_crate_model_queue_search_criteria(
&mut object_608,
item_607,
)?;
object_608.finish();
}
}
array_606.finish();
}
if let Some(var_609) = &input.and_conditions {
let mut array_610 = object.key("AndConditions").start_array();
for item_611 in var_609 {
{
#[allow(unused_mut)]
let mut object_612 = array_610.value().start_object();
crate::json_ser::serialize_structure_crate_model_queue_search_criteria(
&mut object_612,
item_611,
)?;
object_612.finish();
}
}
array_610.finish();
}
if let Some(var_613) = &input.string_condition {
#[allow(unused_mut)]
let mut object_614 = object.key("StringCondition").start_object();
crate::json_ser::serialize_structure_crate_model_string_condition(
&mut object_614,
var_613,
)?;
object_614.finish();
}
if let Some(var_615) = &input.queue_type_condition {
object.key("QueueTypeCondition").string(var_615.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_queue_search_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::QueueSearchFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_616) = &input.tag_filter {
#[allow(unused_mut)]
let mut object_617 = object.key("TagFilter").start_object();
crate::json_ser::serialize_structure_crate_model_control_plane_tag_filter(
&mut object_617,
var_616,
)?;
object_617.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_routing_profile_search_criteria(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RoutingProfileSearchCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_618) = &input.or_conditions {
let mut array_619 = object.key("OrConditions").start_array();
for item_620 in var_618 {
{
#[allow(unused_mut)]
let mut object_621 = array_619.value().start_object();
crate::json_ser::serialize_structure_crate_model_routing_profile_search_criteria(
&mut object_621,
item_620,
)?;
object_621.finish();
}
}
array_619.finish();
}
if let Some(var_622) = &input.and_conditions {
let mut array_623 = object.key("AndConditions").start_array();
for item_624 in var_622 {
{
#[allow(unused_mut)]
let mut object_625 = array_623.value().start_object();
crate::json_ser::serialize_structure_crate_model_routing_profile_search_criteria(
&mut object_625,
item_624,
)?;
object_625.finish();
}
}
array_623.finish();
}
if let Some(var_626) = &input.string_condition {
#[allow(unused_mut)]
let mut object_627 = object.key("StringCondition").start_object();
crate::json_ser::serialize_structure_crate_model_string_condition(
&mut object_627,
var_626,
)?;
object_627.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_routing_profile_search_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RoutingProfileSearchFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_628) = &input.tag_filter {
#[allow(unused_mut)]
let mut object_629 = object.key("TagFilter").start_object();
crate::json_ser::serialize_structure_crate_model_control_plane_tag_filter(
&mut object_629,
var_628,
)?;
object_629.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_security_profile_search_criteria(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SecurityProfileSearchCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_630) = &input.or_conditions {
let mut array_631 = object.key("OrConditions").start_array();
for item_632 in var_630 {
{
#[allow(unused_mut)]
let mut object_633 = array_631.value().start_object();
crate::json_ser::serialize_structure_crate_model_security_profile_search_criteria(
&mut object_633,
item_632,
)?;
object_633.finish();
}
}
array_631.finish();
}
if let Some(var_634) = &input.and_conditions {
let mut array_635 = object.key("AndConditions").start_array();
for item_636 in var_634 {
{
#[allow(unused_mut)]
let mut object_637 = array_635.value().start_object();
crate::json_ser::serialize_structure_crate_model_security_profile_search_criteria(
&mut object_637,
item_636,
)?;
object_637.finish();
}
}
array_635.finish();
}
if let Some(var_638) = &input.string_condition {
#[allow(unused_mut)]
let mut object_639 = object.key("StringCondition").start_object();
crate::json_ser::serialize_structure_crate_model_string_condition(
&mut object_639,
var_638,
)?;
object_639.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_security_profiles_search_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SecurityProfilesSearchFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_640) = &input.tag_filter {
#[allow(unused_mut)]
let mut object_641 = object.key("TagFilter").start_object();
crate::json_ser::serialize_structure_crate_model_control_plane_tag_filter(
&mut object_641,
var_640,
)?;
object_641.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_user_search_criteria(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UserSearchCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_642) = &input.or_conditions {
let mut array_643 = object.key("OrConditions").start_array();
for item_644 in var_642 {
{
#[allow(unused_mut)]
let mut object_645 = array_643.value().start_object();
crate::json_ser::serialize_structure_crate_model_user_search_criteria(
&mut object_645,
item_644,
)?;
object_645.finish();
}
}
array_643.finish();
}
if let Some(var_646) = &input.and_conditions {
let mut array_647 = object.key("AndConditions").start_array();
for item_648 in var_646 {
{
#[allow(unused_mut)]
let mut object_649 = array_647.value().start_object();
crate::json_ser::serialize_structure_crate_model_user_search_criteria(
&mut object_649,
item_648,
)?;
object_649.finish();
}
}
array_647.finish();
}
if let Some(var_650) = &input.string_condition {
#[allow(unused_mut)]
let mut object_651 = object.key("StringCondition").start_object();
crate::json_ser::serialize_structure_crate_model_string_condition(
&mut object_651,
var_650,
)?;
object_651.finish();
}
if let Some(var_652) = &input.hierarchy_group_condition {
#[allow(unused_mut)]
let mut object_653 = object.key("HierarchyGroupCondition").start_object();
crate::json_ser::serialize_structure_crate_model_hierarchy_group_condition(
&mut object_653,
var_652,
)?;
object_653.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_user_search_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UserSearchFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_654) = &input.tag_filter {
#[allow(unused_mut)]
let mut object_655 = object.key("TagFilter").start_object();
crate::json_ser::serialize_structure_crate_model_control_plane_tag_filter(
&mut object_655,
var_654,
)?;
object_655.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_chat_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ChatMessage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_656) = &input.content_type {
object.key("ContentType").string(var_656.as_str());
}
if let Some(var_657) = &input.content {
object.key("Content").string(var_657.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_participant_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParticipantDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_658) = &input.display_name {
object.key("DisplayName").string(var_658.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_persistent_chat(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PersistentChat,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_659) = &input.rehydration_type {
object.key("RehydrationType").string(var_659.as_str());
}
if let Some(var_660) = &input.source_contact_id {
object.key("SourceContactId").string(var_660.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_voice_recording_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VoiceRecordingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_661) = &input.voice_recording_track {
object.key("VoiceRecordingTrack").string(var_661.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_chat_streaming_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ChatStreamingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_662) = &input.streaming_endpoint_arn {
object.key("StreamingEndpointArn").string(var_662.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_answer_machine_detection_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AnswerMachineDetectionConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enable_answer_machine_detection {
object
.key("EnableAnswerMachineDetection")
.boolean(input.enable_answer_machine_detection);
}
if input.await_answer_machine_prompt {
object
.key("AwaitAnswerMachinePrompt")
.boolean(input.await_answer_machine_prompt);
}
Ok(())
}
pub fn serialize_structure_crate_model_reference(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Reference,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_663) = &input.value {
object.key("Value").string(var_663.as_str());
}
if let Some(var_664) = &input.r#type {
object.key("Type").string(var_664.as_str());
}
Ok(())
}
pub fn serialize_union_crate_model_update_participant_role_config_channel_info(
object_428: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateParticipantRoleConfigChannelInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::UpdateParticipantRoleConfigChannelInfo::Chat(inner) => {
#[allow(unused_mut)]
let mut object_665 = object_428.key("Chat").start_object();
crate::json_ser::serialize_structure_crate_model_chat_participant_role_config(
&mut object_665,
inner,
)?;
object_665.finish();
}
crate::model::UpdateParticipantRoleConfigChannelInfo::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"UpdateParticipantRoleConfigChannelInfo",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_telephony_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TelephonyConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_666) = &input.distributions {
let mut array_667 = object.key("Distributions").start_array();
for item_668 in var_666 {
{
#[allow(unused_mut)]
let mut object_669 = array_667.value().start_object();
crate::json_ser::serialize_structure_crate_model_distribution(
&mut object_669,
item_668,
)?;
object_669.finish();
}
}
array_667.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_hierarchy_structure_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HierarchyStructureUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_670) = &input.level_one {
#[allow(unused_mut)]
let mut object_671 = object.key("LevelOne").start_object();
crate::json_ser::serialize_structure_crate_model_hierarchy_level_update(
&mut object_671,
var_670,
)?;
object_671.finish();
}
if let Some(var_672) = &input.level_two {
#[allow(unused_mut)]
let mut object_673 = object.key("LevelTwo").start_object();
crate::json_ser::serialize_structure_crate_model_hierarchy_level_update(
&mut object_673,
var_672,
)?;
object_673.finish();
}
if let Some(var_674) = &input.level_three {
#[allow(unused_mut)]
let mut object_675 = object.key("LevelThree").start_object();
crate::json_ser::serialize_structure_crate_model_hierarchy_level_update(
&mut object_675,
var_674,
)?;
object_675.finish();
}
if let Some(var_676) = &input.level_four {
#[allow(unused_mut)]
let mut object_677 = object.key("LevelFour").start_object();
crate::json_ser::serialize_structure_crate_model_hierarchy_level_update(
&mut object_677,
var_676,
)?;
object_677.finish();
}
if let Some(var_678) = &input.level_five {
#[allow(unused_mut)]
let mut object_679 = object.key("LevelFive").start_object();
crate::json_ser::serialize_structure_crate_model_hierarchy_level_update(
&mut object_679,
var_678,
)?;
object_679.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3Config,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_680) = &input.bucket_name {
object.key("BucketName").string(var_680.as_str());
}
if let Some(var_681) = &input.bucket_prefix {
object.key("BucketPrefix").string(var_681.as_str());
}
if let Some(var_682) = &input.encryption_config {
#[allow(unused_mut)]
let mut object_683 = object.key("EncryptionConfig").start_object();
crate::json_ser::serialize_structure_crate_model_encryption_config(
&mut object_683,
var_682,
)?;
object_683.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_kinesis_video_stream_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KinesisVideoStreamConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_684) = &input.prefix {
object.key("Prefix").string(var_684.as_str());
}
{
object.key("RetentionPeriodHours").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.retention_period_hours).into()),
);
}
if let Some(var_685) = &input.encryption_config {
#[allow(unused_mut)]
let mut object_686 = object.key("EncryptionConfig").start_object();
crate::json_ser::serialize_structure_crate_model_encryption_config(
&mut object_686,
var_685,
)?;
object_686.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_kinesis_stream_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KinesisStreamConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_687) = &input.stream_arn {
object.key("StreamArn").string(var_687.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_kinesis_firehose_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KinesisFirehoseConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_688) = &input.firehose_arn {
object.key("FirehoseArn").string(var_688.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_hours_of_operation_time_slice(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HoursOfOperationTimeSlice,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_689) = &input.hours {
object.key("Hours").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_689).into()),
);
}
if let Some(var_690) = &input.minutes {
object.key("Minutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_690).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_user_quick_connect_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UserQuickConnectConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_691) = &input.user_id {
object.key("UserId").string(var_691.as_str());
}
if let Some(var_692) = &input.contact_flow_id {
object.key("ContactFlowId").string(var_692.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_queue_quick_connect_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::QueueQuickConnectConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_693) = &input.queue_id {
object.key("QueueId").string(var_693.as_str());
}
if let Some(var_694) = &input.contact_flow_id {
object.key("ContactFlowId").string(var_694.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_phone_number_quick_connect_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PhoneNumberQuickConnectConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_695) = &input.phone_number {
object.key("PhoneNumber").string(var_695.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_task_action_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TaskActionDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_696) = &input.name {
object.key("Name").string(var_696.as_str());
}
if let Some(var_697) = &input.description {
object.key("Description").string(var_697.as_str());
}
if let Some(var_698) = &input.contact_flow_id {
object.key("ContactFlowId").string(var_698.as_str());
}
if let Some(var_699) = &input.references {
#[allow(unused_mut)]
let mut object_700 = object.key("References").start_object();
for (key_701, value_702) in var_699 {
{
#[allow(unused_mut)]
let mut object_703 = object_700.key(key_701.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_reference(
&mut object_703,
value_702,
)?;
object_703.finish();
}
}
object_700.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_event_bridge_action_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EventBridgeActionDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_704) = &input.name {
object.key("Name").string(var_704.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_assign_contact_category_action_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AssignContactCategoryActionDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
let (_, _) = (object, input);
Ok(())
}
pub fn serialize_structure_crate_model_send_notification_action_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SendNotificationActionDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_705) = &input.delivery_method {
object.key("DeliveryMethod").string(var_705.as_str());
}
if let Some(var_706) = &input.subject {
object.key("Subject").string(var_706.as_str());
}
if let Some(var_707) = &input.content {
object.key("Content").string(var_707.as_str());
}
if let Some(var_708) = &input.content_type {
object.key("ContentType").string(var_708.as_str());
}
if let Some(var_709) = &input.recipient {
#[allow(unused_mut)]
let mut object_710 = object.key("Recipient").start_object();
crate::json_ser::serialize_structure_crate_model_notification_recipient_type(
&mut object_710,
var_709,
)?;
object_710.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_required_field_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RequiredFieldInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_711) = &input.id {
#[allow(unused_mut)]
let mut object_712 = object.key("Id").start_object();
crate::json_ser::serialize_structure_crate_model_task_template_field_identifier(
&mut object_712,
var_711,
)?;
object_712.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_read_only_field_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReadOnlyFieldInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_713) = &input.id {
#[allow(unused_mut)]
let mut object_714 = object.key("Id").start_object();
crate::json_ser::serialize_structure_crate_model_task_template_field_identifier(
&mut object_714,
var_713,
)?;
object_714.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_invisible_field_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InvisibleFieldInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_715) = &input.id {
#[allow(unused_mut)]
let mut object_716 = object.key("Id").start_object();
crate::json_ser::serialize_structure_crate_model_task_template_field_identifier(
&mut object_716,
var_715,
)?;
object_716.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_task_template_default_field_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TaskTemplateDefaultFieldValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_717) = &input.id {
#[allow(unused_mut)]
let mut object_718 = object.key("Id").start_object();
crate::json_ser::serialize_structure_crate_model_task_template_field_identifier(
&mut object_718,
var_717,
)?;
object_718.finish();
}
if let Some(var_719) = &input.default_value {
object.key("DefaultValue").string(var_719.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_task_template_field_identifier(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TaskTemplateFieldIdentifier,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_720) = &input.name {
object.key("Name").string(var_720.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_contact_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ContactFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_721) = &input.contact_states {
let mut array_722 = object.key("ContactStates").start_array();
for item_723 in var_721 {
{
array_722.value().string(item_723.as_str());
}
}
array_722.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_threshold(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Threshold,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_724) = &input.comparison {
object.key("Comparison").string(var_724.as_str());
}
if let Some(var_725) = &input.threshold_value {
object.key("ThresholdValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_725).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_string_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StringCondition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_726) = &input.field_name {
object.key("FieldName").string(var_726.as_str());
}
if let Some(var_727) = &input.value {
object.key("Value").string(var_727.as_str());
}
if let Some(var_728) = &input.comparison_type {
object.key("ComparisonType").string(var_728.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_control_plane_tag_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ControlPlaneTagFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_729) = &input.or_conditions {
let mut array_730 = object.key("OrConditions").start_array();
for item_731 in var_729 {
{
let mut array_732 = array_730.value().start_array();
for item_733 in item_731 {
{
#[allow(unused_mut)]
let mut object_734 = array_732.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_condition(
&mut object_734,
item_733,
)?;
object_734.finish();
}
}
array_732.finish();
}
}
array_730.finish();
}
if let Some(var_735) = &input.and_conditions {
let mut array_736 = object.key("AndConditions").start_array();
for item_737 in var_735 {
{
#[allow(unused_mut)]
let mut object_738 = array_736.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_condition(
&mut object_738,
item_737,
)?;
object_738.finish();
}
}
array_736.finish();
}
if let Some(var_739) = &input.tag_condition {
#[allow(unused_mut)]
let mut object_740 = object.key("TagCondition").start_object();
crate::json_ser::serialize_structure_crate_model_tag_condition(&mut object_740, var_739)?;
object_740.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_hierarchy_group_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HierarchyGroupCondition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_741) = &input.value {
object.key("Value").string(var_741.as_str());
}
if let Some(var_742) = &input.hierarchy_group_match_type {
object
.key("HierarchyGroupMatchType")
.string(var_742.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_chat_participant_role_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ChatParticipantRoleConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_743) = &input.participant_timer_config_list {
let mut array_744 = object.key("ParticipantTimerConfigList").start_array();
for item_745 in var_743 {
{
#[allow(unused_mut)]
let mut object_746 = array_744.value().start_object();
crate::json_ser::serialize_structure_crate_model_participant_timer_configuration(
&mut object_746,
item_745,
)?;
object_746.finish();
}
}
array_744.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_distribution(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Distribution,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_747) = &input.region {
object.key("Region").string(var_747.as_str());
}
{
object.key("Percentage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.percentage).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_hierarchy_level_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HierarchyLevelUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_748) = &input.name {
object.key("Name").string(var_748.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_encryption_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EncryptionConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_749) = &input.encryption_type {
object.key("EncryptionType").string(var_749.as_str());
}
if let Some(var_750) = &input.key_id {
object.key("KeyId").string(var_750.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_notification_recipient_type(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NotificationRecipientType,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_751) = &input.user_tags {
#[allow(unused_mut)]
let mut object_752 = object.key("UserTags").start_object();
for (key_753, value_754) in var_751 {
{
object_752.key(key_753.as_str()).string(value_754.as_str());
}
}
object_752.finish();
}
if let Some(var_755) = &input.user_ids {
let mut array_756 = object.key("UserIds").start_array();
for item_757 in var_755 {
{
array_756.value().string(item_757.as_str());
}
}
array_756.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tag_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TagCondition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_758) = &input.tag_key {
object.key("TagKey").string(var_758.as_str());
}
if let Some(var_759) = &input.tag_value {
object.key("TagValue").string(var_759.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_participant_timer_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParticipantTimerConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_760) = &input.participant_role {
object.key("ParticipantRole").string(var_760.as_str());
}
if let Some(var_761) = &input.timer_type {
object.key("TimerType").string(var_761.as_str());
}
if let Some(var_762) = &input.timer_value {
#[allow(unused_mut)]
let mut object_763 = object.key("TimerValue").start_object();
crate::json_ser::serialize_union_crate_model_participant_timer_value(
&mut object_763,
var_762,
)?;
object_763.finish();
}
Ok(())
}
pub fn serialize_union_crate_model_participant_timer_value(
object_763: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParticipantTimerValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::ParticipantTimerValue::ParticipantTimerAction(inner) => {
object_763
.key("ParticipantTimerAction")
.string(inner.as_str());
}
crate::model::ParticipantTimerValue::ParticipantTimerDurationInMinutes(inner) => {
object_763.key("ParticipantTimerDurationInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*inner).into()),
);
}
crate::model::ParticipantTimerValue::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"ParticipantTimerValue",
),
)
}
}
Ok(())
}