pub fn serialize_structure_crate_input_associate_user_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateUserInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.domain {
object.key("Domain").string(var_1.as_str());
}
if let Some(var_2) = &input.identity_provider {
#[allow(unused_mut)]
let mut object_3 = object.key("IdentityProvider").start_object();
crate::json_ser::serialize_union_crate_model_identity_provider(&mut object_3, var_2)?;
object_3.finish();
}
if let Some(var_4) = &input.instance_id {
object.key("InstanceId").string(var_4.as_str());
}
if let Some(var_5) = &input.username {
object.key("Username").string(var_5.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_deregister_identity_provider_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeregisterIdentityProviderInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_6) = &input.identity_provider {
#[allow(unused_mut)]
let mut object_7 = object.key("IdentityProvider").start_object();
crate::json_ser::serialize_union_crate_model_identity_provider(&mut object_7, var_6)?;
object_7.finish();
}
if let Some(var_8) = &input.product {
object.key("Product").string(var_8.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_user_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateUserInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_9) = &input.domain {
object.key("Domain").string(var_9.as_str());
}
if let Some(var_10) = &input.identity_provider {
#[allow(unused_mut)]
let mut object_11 = object.key("IdentityProvider").start_object();
crate::json_ser::serialize_union_crate_model_identity_provider(&mut object_11, var_10)?;
object_11.finish();
}
if let Some(var_12) = &input.instance_id {
object.key("InstanceId").string(var_12.as_str());
}
if let Some(var_13) = &input.username {
object.key("Username").string(var_13.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_identity_providers_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListIdentityProvidersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_14) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_14).into()),
);
}
if let Some(var_15) = &input.next_token {
object.key("NextToken").string(var_15.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_instances_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListInstancesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_16) = &input.filters {
let mut array_17 = object.key("Filters").start_array();
for item_18 in var_16 {
{
#[allow(unused_mut)]
let mut object_19 = array_17.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_19, item_18)?;
object_19.finish();
}
}
array_17.finish();
}
if let Some(var_20) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_20).into()),
);
}
if let Some(var_21) = &input.next_token {
object.key("NextToken").string(var_21.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_product_subscriptions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListProductSubscriptionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_22) = &input.filters {
let mut array_23 = object.key("Filters").start_array();
for item_24 in var_22 {
{
#[allow(unused_mut)]
let mut object_25 = array_23.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_25, item_24)?;
object_25.finish();
}
}
array_23.finish();
}
if let Some(var_26) = &input.identity_provider {
#[allow(unused_mut)]
let mut object_27 = object.key("IdentityProvider").start_object();
crate::json_ser::serialize_union_crate_model_identity_provider(&mut object_27, var_26)?;
object_27.finish();
}
if let Some(var_28) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_28).into()),
);
}
if let Some(var_29) = &input.next_token {
object.key("NextToken").string(var_29.as_str());
}
if let Some(var_30) = &input.product {
object.key("Product").string(var_30.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_user_associations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListUserAssociationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_31) = &input.filters {
let mut array_32 = object.key("Filters").start_array();
for item_33 in var_31 {
{
#[allow(unused_mut)]
let mut object_34 = array_32.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_34, item_33)?;
object_34.finish();
}
}
array_32.finish();
}
if let Some(var_35) = &input.identity_provider {
#[allow(unused_mut)]
let mut object_36 = object.key("IdentityProvider").start_object();
crate::json_ser::serialize_union_crate_model_identity_provider(&mut object_36, var_35)?;
object_36.finish();
}
if let Some(var_37) = &input.instance_id {
object.key("InstanceId").string(var_37.as_str());
}
if let Some(var_38) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_38).into()),
);
}
if let Some(var_39) = &input.next_token {
object.key("NextToken").string(var_39.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_register_identity_provider_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterIdentityProviderInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_40) = &input.identity_provider {
#[allow(unused_mut)]
let mut object_41 = object.key("IdentityProvider").start_object();
crate::json_ser::serialize_union_crate_model_identity_provider(&mut object_41, var_40)?;
object_41.finish();
}
if let Some(var_42) = &input.product {
object.key("Product").string(var_42.as_str());
}
if let Some(var_43) = &input.settings {
#[allow(unused_mut)]
let mut object_44 = object.key("Settings").start_object();
crate::json_ser::serialize_structure_crate_model_settings(&mut object_44, var_43)?;
object_44.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_product_subscription_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartProductSubscriptionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_45) = &input.domain {
object.key("Domain").string(var_45.as_str());
}
if let Some(var_46) = &input.identity_provider {
#[allow(unused_mut)]
let mut object_47 = object.key("IdentityProvider").start_object();
crate::json_ser::serialize_union_crate_model_identity_provider(&mut object_47, var_46)?;
object_47.finish();
}
if let Some(var_48) = &input.product {
object.key("Product").string(var_48.as_str());
}
if let Some(var_49) = &input.username {
object.key("Username").string(var_49.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_product_subscription_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopProductSubscriptionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_50) = &input.domain {
object.key("Domain").string(var_50.as_str());
}
if let Some(var_51) = &input.identity_provider {
#[allow(unused_mut)]
let mut object_52 = object.key("IdentityProvider").start_object();
crate::json_ser::serialize_union_crate_model_identity_provider(&mut object_52, var_51)?;
object_52.finish();
}
if let Some(var_53) = &input.product {
object.key("Product").string(var_53.as_str());
}
if let Some(var_54) = &input.username {
object.key("Username").string(var_54.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_identity_provider_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateIdentityProviderSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_55) = &input.identity_provider {
#[allow(unused_mut)]
let mut object_56 = object.key("IdentityProvider").start_object();
crate::json_ser::serialize_union_crate_model_identity_provider(&mut object_56, var_55)?;
object_56.finish();
}
if let Some(var_57) = &input.product {
object.key("Product").string(var_57.as_str());
}
if let Some(var_58) = &input.update_settings {
#[allow(unused_mut)]
let mut object_59 = object.key("UpdateSettings").start_object();
crate::json_ser::serialize_structure_crate_model_update_settings(&mut object_59, var_58)?;
object_59.finish();
}
Ok(())
}
pub fn serialize_union_crate_model_identity_provider(
object_3: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IdentityProvider,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::IdentityProvider::ActiveDirectoryIdentityProvider(inner) => {
#[allow(unused_mut)]
let mut object_60 = object_3
.key("ActiveDirectoryIdentityProvider")
.start_object();
crate::json_ser::serialize_structure_crate_model_active_directory_identity_provider(
&mut object_60,
inner,
)?;
object_60.finish();
}
crate::model::IdentityProvider::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"IdentityProvider",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Filter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_61) = &input.attribute {
object.key("Attribute").string(var_61.as_str());
}
if let Some(var_62) = &input.operation {
object.key("Operation").string(var_62.as_str());
}
if let Some(var_63) = &input.value {
object.key("Value").string(var_63.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Settings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_64) = &input.subnets {
let mut array_65 = object.key("Subnets").start_array();
for item_66 in var_64 {
{
array_65.value().string(item_66.as_str());
}
}
array_65.finish();
}
if let Some(var_67) = &input.security_group_id {
object.key("SecurityGroupId").string(var_67.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_update_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_68) = &input.add_subnets {
let mut array_69 = object.key("AddSubnets").start_array();
for item_70 in var_68 {
{
array_69.value().string(item_70.as_str());
}
}
array_69.finish();
}
if let Some(var_71) = &input.remove_subnets {
let mut array_72 = object.key("RemoveSubnets").start_array();
for item_73 in var_71 {
{
array_72.value().string(item_73.as_str());
}
}
array_72.finish();
}
if let Some(var_74) = &input.security_group_id {
object.key("SecurityGroupId").string(var_74.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_active_directory_identity_provider(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ActiveDirectoryIdentityProvider,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_75) = &input.directory_id {
object.key("DirectoryId").string(var_75.as_str());
}
Ok(())
}