pub fn serialize_structure_crate_input_create_browser_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBrowserSettingsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_1) = &input.additional_encryption_context {
let mut object_2 = object.key("additionalEncryptionContext").start_object();
for (key_3, value_4) in var_1 {
{
object_2.key(key_3).string(value_4.as_str());
}
}
object_2.finish();
}
if let Some(var_5) = &input.browser_policy {
object.key("browserPolicy").string(var_5.as_str());
}
if let Some(var_6) = &input.client_token {
object.key("clientToken").string(var_6.as_str());
}
if let Some(var_7) = &input.customer_managed_key {
object.key("customerManagedKey").string(var_7.as_str());
}
if let Some(var_8) = &input.tags {
let mut array_9 = object.key("tags").start_array();
for item_10 in var_8 {
{
let mut object_11 = array_9.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_11, item_10)?;
object_11.finish();
}
}
array_9.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_identity_provider_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateIdentityProviderInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_12) = &input.client_token {
object.key("clientToken").string(var_12.as_str());
}
if let Some(var_13) = &input.identity_provider_details {
let mut object_14 = object.key("identityProviderDetails").start_object();
for (key_15, value_16) in var_13 {
{
object_14.key(key_15).string(value_16.as_str());
}
}
object_14.finish();
}
if let Some(var_17) = &input.identity_provider_name {
object.key("identityProviderName").string(var_17.as_str());
}
if let Some(var_18) = &input.identity_provider_type {
object.key("identityProviderType").string(var_18.as_str());
}
if let Some(var_19) = &input.portal_arn {
object.key("portalArn").string(var_19.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_network_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateNetworkSettingsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_20) = &input.client_token {
object.key("clientToken").string(var_20.as_str());
}
if let Some(var_21) = &input.security_group_ids {
let mut array_22 = object.key("securityGroupIds").start_array();
for item_23 in var_21 {
{
array_22.value().string(item_23.as_str());
}
}
array_22.finish();
}
if let Some(var_24) = &input.subnet_ids {
let mut array_25 = object.key("subnetIds").start_array();
for item_26 in var_24 {
{
array_25.value().string(item_26.as_str());
}
}
array_25.finish();
}
if let Some(var_27) = &input.tags {
let mut array_28 = object.key("tags").start_array();
for item_29 in var_27 {
{
let mut object_30 = array_28.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_30, item_29)?;
object_30.finish();
}
}
array_28.finish();
}
if let Some(var_31) = &input.vpc_id {
object.key("vpcId").string(var_31.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_portal_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreatePortalInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_32) = &input.additional_encryption_context {
let mut object_33 = object.key("additionalEncryptionContext").start_object();
for (key_34, value_35) in var_32 {
{
object_33.key(key_34).string(value_35.as_str());
}
}
object_33.finish();
}
if let Some(var_36) = &input.client_token {
object.key("clientToken").string(var_36.as_str());
}
if let Some(var_37) = &input.customer_managed_key {
object.key("customerManagedKey").string(var_37.as_str());
}
if let Some(var_38) = &input.display_name {
object.key("displayName").string(var_38.as_str());
}
if let Some(var_39) = &input.tags {
let mut array_40 = object.key("tags").start_array();
for item_41 in var_39 {
{
let mut object_42 = array_40.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_42, item_41)?;
object_42.finish();
}
}
array_40.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_trust_store_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateTrustStoreInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_43) = &input.certificate_list {
let mut array_44 = object.key("certificateList").start_array();
for item_45 in var_43 {
{
array_44
.value()
.string_unchecked(&aws_smithy_types::base64::encode(item_45));
}
}
array_44.finish();
}
if let Some(var_46) = &input.client_token {
object.key("clientToken").string(var_46.as_str());
}
if let Some(var_47) = &input.tags {
let mut array_48 = object.key("tags").start_array();
for item_49 in var_47 {
{
let mut object_50 = array_48.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_50, item_49)?;
object_50.finish();
}
}
array_48.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_user_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateUserSettingsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_51) = &input.client_token {
object.key("clientToken").string(var_51.as_str());
}
if let Some(var_52) = &input.copy_allowed {
object.key("copyAllowed").string(var_52.as_str());
}
if let Some(var_53) = &input.download_allowed {
object.key("downloadAllowed").string(var_53.as_str());
}
if let Some(var_54) = &input.paste_allowed {
object.key("pasteAllowed").string(var_54.as_str());
}
if let Some(var_55) = &input.print_allowed {
object.key("printAllowed").string(var_55.as_str());
}
if let Some(var_56) = &input.tags {
let mut array_57 = object.key("tags").start_array();
for item_58 in var_56 {
{
let mut object_59 = array_57.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_59, item_58)?;
object_59.finish();
}
}
array_57.finish();
}
if let Some(var_60) = &input.upload_allowed {
object.key("uploadAllowed").string(var_60.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::SerializationError> {
if let Some(var_61) = &input.client_token {
object.key("clientToken").string(var_61.as_str());
}
if let Some(var_62) = &input.tags {
let mut array_63 = object.key("tags").start_array();
for item_64 in var_62 {
{
let mut object_65 = array_63.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_65, item_64)?;
object_65.finish();
}
}
array_63.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_browser_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateBrowserSettingsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_66) = &input.browser_policy {
object.key("browserPolicy").string(var_66.as_str());
}
if let Some(var_67) = &input.client_token {
object.key("clientToken").string(var_67.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_identity_provider_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateIdentityProviderInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_68) = &input.client_token {
object.key("clientToken").string(var_68.as_str());
}
if let Some(var_69) = &input.identity_provider_details {
let mut object_70 = object.key("identityProviderDetails").start_object();
for (key_71, value_72) in var_69 {
{
object_70.key(key_71).string(value_72.as_str());
}
}
object_70.finish();
}
if let Some(var_73) = &input.identity_provider_name {
object.key("identityProviderName").string(var_73.as_str());
}
if let Some(var_74) = &input.identity_provider_type {
object.key("identityProviderType").string(var_74.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_network_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateNetworkSettingsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_75) = &input.client_token {
object.key("clientToken").string(var_75.as_str());
}
if let Some(var_76) = &input.security_group_ids {
let mut array_77 = object.key("securityGroupIds").start_array();
for item_78 in var_76 {
{
array_77.value().string(item_78.as_str());
}
}
array_77.finish();
}
if let Some(var_79) = &input.subnet_ids {
let mut array_80 = object.key("subnetIds").start_array();
for item_81 in var_79 {
{
array_80.value().string(item_81.as_str());
}
}
array_80.finish();
}
if let Some(var_82) = &input.vpc_id {
object.key("vpcId").string(var_82.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_portal_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdatePortalInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_83) = &input.display_name {
object.key("displayName").string(var_83.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_trust_store_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateTrustStoreInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_84) = &input.certificates_to_add {
let mut array_85 = object.key("certificatesToAdd").start_array();
for item_86 in var_84 {
{
array_85
.value()
.string_unchecked(&aws_smithy_types::base64::encode(item_86));
}
}
array_85.finish();
}
if let Some(var_87) = &input.certificates_to_delete {
let mut array_88 = object.key("certificatesToDelete").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.client_token {
object.key("clientToken").string(var_90.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_user_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateUserSettingsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_91) = &input.client_token {
object.key("clientToken").string(var_91.as_str());
}
if let Some(var_92) = &input.copy_allowed {
object.key("copyAllowed").string(var_92.as_str());
}
if let Some(var_93) = &input.download_allowed {
object.key("downloadAllowed").string(var_93.as_str());
}
if let Some(var_94) = &input.paste_allowed {
object.key("pasteAllowed").string(var_94.as_str());
}
if let Some(var_95) = &input.print_allowed {
object.key("printAllowed").string(var_95.as_str());
}
if let Some(var_96) = &input.upload_allowed {
object.key("uploadAllowed").string(var_96.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_97) = &input.key {
object.key("Key").string(var_97.as_str());
}
if let Some(var_98) = &input.value {
object.key("Value").string(var_98.as_str());
}
Ok(())
}