pub fn serialize_structure_crate_input_create_campaign_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateCampaignInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.connect_instance_id {
object.key("connectInstanceId").string(var_1.as_str());
}
if let Some(var_2) = &input.dialer_config {
#[allow(unused_mut)]
let mut object_3 = object.key("dialerConfig").start_object();
crate::json_ser::serialize_union_crate_model_dialer_config(&mut object_3, var_2)?;
object_3.finish();
}
if let Some(var_4) = &input.name {
object.key("name").string(var_4.as_str());
}
if let Some(var_5) = &input.outbound_call_config {
#[allow(unused_mut)]
let mut object_6 = object.key("outboundCallConfig").start_object();
crate::json_ser::serialize_structure_crate_model_outbound_call_config(
&mut object_6,
var_5,
)?;
object_6.finish();
}
if let Some(var_7) = &input.tags {
#[allow(unused_mut)]
let mut object_8 = object.key("tags").start_object();
for (key_9, value_10) in var_7 {
{
object_8.key(key_9.as_str()).string(value_10.as_str());
}
}
object_8.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_campaign_state_batch_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetCampaignStateBatchInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_11) = &input.campaign_ids {
let mut array_12 = object.key("campaignIds").start_array();
for item_13 in var_11 {
{
array_12.value().string(item_13.as_str());
}
}
array_12.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_campaigns_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListCampaignsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_14) = &input.filters {
#[allow(unused_mut)]
let mut object_15 = object.key("filters").start_object();
crate::json_ser::serialize_structure_crate_model_campaign_filters(&mut object_15, var_14)?;
object_15.finish();
}
if let Some(var_16) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_16).into()),
);
}
if let Some(var_17) = &input.next_token {
object.key("nextToken").string(var_17.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_dial_request_batch_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutDialRequestBatchInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_18) = &input.dial_requests {
let mut array_19 = object.key("dialRequests").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_dial_request(
&mut object_21,
item_20,
)?;
object_21.finish();
}
}
array_19.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_instance_onboarding_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartInstanceOnboardingJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_22) = &input.encryption_config {
#[allow(unused_mut)]
let mut object_23 = object.key("encryptionConfig").start_object();
crate::json_ser::serialize_structure_crate_model_encryption_config(&mut object_23, var_22)?;
object_23.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_24) = &input.tags {
#[allow(unused_mut)]
let mut object_25 = object.key("tags").start_object();
for (key_26, value_27) in var_24 {
{
object_25.key(key_26.as_str()).string(value_27.as_str());
}
}
object_25.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_campaign_dialer_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateCampaignDialerConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_28) = &input.dialer_config {
#[allow(unused_mut)]
let mut object_29 = object.key("dialerConfig").start_object();
crate::json_ser::serialize_union_crate_model_dialer_config(&mut object_29, var_28)?;
object_29.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_campaign_name_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateCampaignNameInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_30) = &input.name {
object.key("name").string(var_30.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_campaign_outbound_call_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateCampaignOutboundCallConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_31) = &input.answer_machine_detection_config {
#[allow(unused_mut)]
let mut object_32 = object.key("answerMachineDetectionConfig").start_object();
crate::json_ser::serialize_structure_crate_model_answer_machine_detection_config(
&mut object_32,
var_31,
)?;
object_32.finish();
}
if let Some(var_33) = &input.connect_contact_flow_id {
object.key("connectContactFlowId").string(var_33.as_str());
}
if let Some(var_34) = &input.connect_source_phone_number {
object
.key("connectSourcePhoneNumber")
.string(var_34.as_str());
}
Ok(())
}
pub fn serialize_union_crate_model_dialer_config(
object_3: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DialerConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::DialerConfig::ProgressiveDialerConfig(inner) => {
#[allow(unused_mut)]
let mut object_35 = object_3.key("progressiveDialerConfig").start_object();
crate::json_ser::serialize_structure_crate_model_progressive_dialer_config(
&mut object_35,
inner,
)?;
object_35.finish();
}
crate::model::DialerConfig::PredictiveDialerConfig(inner) => {
#[allow(unused_mut)]
let mut object_36 = object_3.key("predictiveDialerConfig").start_object();
crate::json_ser::serialize_structure_crate_model_predictive_dialer_config(
&mut object_36,
inner,
)?;
object_36.finish();
}
crate::model::DialerConfig::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"DialerConfig",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_outbound_call_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OutboundCallConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_37) = &input.connect_contact_flow_id {
object.key("connectContactFlowId").string(var_37.as_str());
}
if let Some(var_38) = &input.connect_source_phone_number {
object
.key("connectSourcePhoneNumber")
.string(var_38.as_str());
}
if let Some(var_39) = &input.connect_queue_id {
object.key("connectQueueId").string(var_39.as_str());
}
if let Some(var_40) = &input.answer_machine_detection_config {
#[allow(unused_mut)]
let mut object_41 = object.key("answerMachineDetectionConfig").start_object();
crate::json_ser::serialize_structure_crate_model_answer_machine_detection_config(
&mut object_41,
var_40,
)?;
object_41.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_campaign_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CampaignFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_42) = &input.instance_id_filter {
#[allow(unused_mut)]
let mut object_43 = object.key("instanceIdFilter").start_object();
crate::json_ser::serialize_structure_crate_model_instance_id_filter(
&mut object_43,
var_42,
)?;
object_43.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_dial_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DialRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_44) = &input.client_token {
object.key("clientToken").string(var_44.as_str());
}
if let Some(var_45) = &input.phone_number {
object.key("phoneNumber").string(var_45.as_str());
}
if let Some(var_46) = &input.expiration_time {
object
.key("expirationTime")
.date_time(var_46, aws_smithy_types::date_time::Format::DateTime)?;
}
if let Some(var_47) = &input.attributes {
#[allow(unused_mut)]
let mut object_48 = object.key("attributes").start_object();
for (key_49, value_50) in var_47 {
{
object_48.key(key_49.as_str()).string(value_50.as_str());
}
}
object_48.finish();
}
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> {
{
object.key("enabled").boolean(input.enabled);
}
if let Some(var_51) = &input.encryption_type {
object.key("encryptionType").string(var_51.as_str());
}
if let Some(var_52) = &input.key_arn {
object.key("keyArn").string(var_52.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 let Some(var_53) = &input.enable_answer_machine_detection {
object.key("enableAnswerMachineDetection").boolean(*var_53);
}
Ok(())
}
pub fn serialize_structure_crate_model_progressive_dialer_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProgressiveDialerConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_54) = &input.bandwidth_allocation {
object.key("bandwidthAllocation").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_54).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_predictive_dialer_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PredictiveDialerConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_55) = &input.bandwidth_allocation {
object.key("bandwidthAllocation").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_55).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_instance_id_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InstanceIdFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_56) = &input.value {
object.key("value").string(var_56.as_str());
}
if let Some(var_57) = &input.operator {
object.key("operator").string(var_57.as_str());
}
Ok(())
}