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::error::SerializationError> {
if let Some(var_1) = &input.additional_encryption_context {
#[allow(unused_mut)]
let mut object_2 = object.key("additionalEncryptionContext").start_object();
for (key_3, value_4) in var_1 {
{
object_2.key(key_3.as_str()).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 {
{
#[allow(unused_mut)]
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::error::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 {
#[allow(unused_mut)]
let mut object_14 = object.key("identityProviderDetails").start_object();
for (key_15, value_16) in var_13 {
{
object_14.key(key_15.as_str()).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::error::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 {
{
#[allow(unused_mut)]
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::error::SerializationError> {
if let Some(var_32) = &input.additional_encryption_context {
#[allow(unused_mut)]
let mut object_33 = object.key("additionalEncryptionContext").start_object();
for (key_34, value_35) in var_32 {
{
object_33.key(key_34.as_str()).string(value_35.as_str());
}
}
object_33.finish();
}
if let Some(var_36) = &input.authentication_type {
object.key("authenticationType").string(var_36.as_str());
}
if let Some(var_37) = &input.client_token {
object.key("clientToken").string(var_37.as_str());
}
if let Some(var_38) = &input.customer_managed_key {
object.key("customerManagedKey").string(var_38.as_str());
}
if let Some(var_39) = &input.display_name {
object.key("displayName").string(var_39.as_str());
}
if let Some(var_40) = &input.tags {
let mut array_41 = object.key("tags").start_array();
for item_42 in var_40 {
{
#[allow(unused_mut)]
let mut object_43 = array_41.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_43, item_42)?;
object_43.finish();
}
}
array_41.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::error::SerializationError> {
if let Some(var_44) = &input.certificate_list {
let mut array_45 = object.key("certificateList").start_array();
for item_46 in var_44 {
{
array_45
.value()
.string_unchecked(&aws_smithy_types::base64::encode(item_46));
}
}
array_45.finish();
}
if let Some(var_47) = &input.client_token {
object.key("clientToken").string(var_47.as_str());
}
if let Some(var_48) = &input.tags {
let mut array_49 = object.key("tags").start_array();
for item_50 in var_48 {
{
#[allow(unused_mut)]
let mut object_51 = array_49.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_51, item_50)?;
object_51.finish();
}
}
array_49.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_user_access_logging_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateUserAccessLoggingSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_52) = &input.client_token {
object.key("clientToken").string(var_52.as_str());
}
if let Some(var_53) = &input.kinesis_stream_arn {
object.key("kinesisStreamArn").string(var_53.as_str());
}
if let Some(var_54) = &input.tags {
let mut array_55 = object.key("tags").start_array();
for item_56 in var_54 {
{
#[allow(unused_mut)]
let mut object_57 = array_55.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_57, item_56)?;
object_57.finish();
}
}
array_55.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::error::SerializationError> {
if let Some(var_58) = &input.client_token {
object.key("clientToken").string(var_58.as_str());
}
if let Some(var_59) = &input.copy_allowed {
object.key("copyAllowed").string(var_59.as_str());
}
if let Some(var_60) = &input.disconnect_timeout_in_minutes {
object.key("disconnectTimeoutInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_60).into()),
);
}
if let Some(var_61) = &input.download_allowed {
object.key("downloadAllowed").string(var_61.as_str());
}
if let Some(var_62) = &input.idle_disconnect_timeout_in_minutes {
object.key("idleDisconnectTimeoutInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_62).into()),
);
}
if let Some(var_63) = &input.paste_allowed {
object.key("pasteAllowed").string(var_63.as_str());
}
if let Some(var_64) = &input.print_allowed {
object.key("printAllowed").string(var_64.as_str());
}
if let Some(var_65) = &input.tags {
let mut array_66 = object.key("tags").start_array();
for item_67 in var_65 {
{
#[allow(unused_mut)]
let mut object_68 = array_66.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_68, item_67)?;
object_68.finish();
}
}
array_66.finish();
}
if let Some(var_69) = &input.upload_allowed {
object.key("uploadAllowed").string(var_69.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_70) = &input.client_token {
object.key("clientToken").string(var_70.as_str());
}
if let Some(var_71) = &input.tags {
let mut array_72 = object.key("tags").start_array();
for item_73 in var_71 {
{
#[allow(unused_mut)]
let mut object_74 = array_72.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_74, item_73)?;
object_74.finish();
}
}
array_72.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::error::SerializationError> {
if let Some(var_75) = &input.browser_policy {
object.key("browserPolicy").string(var_75.as_str());
}
if let Some(var_76) = &input.client_token {
object.key("clientToken").string(var_76.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::error::SerializationError> {
if let Some(var_77) = &input.client_token {
object.key("clientToken").string(var_77.as_str());
}
if let Some(var_78) = &input.identity_provider_details {
#[allow(unused_mut)]
let mut object_79 = object.key("identityProviderDetails").start_object();
for (key_80, value_81) in var_78 {
{
object_79.key(key_80.as_str()).string(value_81.as_str());
}
}
object_79.finish();
}
if let Some(var_82) = &input.identity_provider_name {
object.key("identityProviderName").string(var_82.as_str());
}
if let Some(var_83) = &input.identity_provider_type {
object.key("identityProviderType").string(var_83.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::error::SerializationError> {
if let Some(var_84) = &input.client_token {
object.key("clientToken").string(var_84.as_str());
}
if let Some(var_85) = &input.security_group_ids {
let mut array_86 = object.key("securityGroupIds").start_array();
for item_87 in var_85 {
{
array_86.value().string(item_87.as_str());
}
}
array_86.finish();
}
if let Some(var_88) = &input.subnet_ids {
let mut array_89 = object.key("subnetIds").start_array();
for item_90 in var_88 {
{
array_89.value().string(item_90.as_str());
}
}
array_89.finish();
}
if let Some(var_91) = &input.vpc_id {
object.key("vpcId").string(var_91.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::error::SerializationError> {
if let Some(var_92) = &input.authentication_type {
object.key("authenticationType").string(var_92.as_str());
}
if let Some(var_93) = &input.display_name {
object.key("displayName").string(var_93.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::error::SerializationError> {
if let Some(var_94) = &input.certificates_to_add {
let mut array_95 = object.key("certificatesToAdd").start_array();
for item_96 in var_94 {
{
array_95
.value()
.string_unchecked(&aws_smithy_types::base64::encode(item_96));
}
}
array_95.finish();
}
if let Some(var_97) = &input.certificates_to_delete {
let mut array_98 = object.key("certificatesToDelete").start_array();
for item_99 in var_97 {
{
array_98.value().string(item_99.as_str());
}
}
array_98.finish();
}
if let Some(var_100) = &input.client_token {
object.key("clientToken").string(var_100.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_user_access_logging_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateUserAccessLoggingSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_101) = &input.client_token {
object.key("clientToken").string(var_101.as_str());
}
if let Some(var_102) = &input.kinesis_stream_arn {
object.key("kinesisStreamArn").string(var_102.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::error::SerializationError> {
if let Some(var_103) = &input.client_token {
object.key("clientToken").string(var_103.as_str());
}
if let Some(var_104) = &input.copy_allowed {
object.key("copyAllowed").string(var_104.as_str());
}
if let Some(var_105) = &input.disconnect_timeout_in_minutes {
object.key("disconnectTimeoutInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_105).into()),
);
}
if let Some(var_106) = &input.download_allowed {
object.key("downloadAllowed").string(var_106.as_str());
}
if let Some(var_107) = &input.idle_disconnect_timeout_in_minutes {
object.key("idleDisconnectTimeoutInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_107).into()),
);
}
if let Some(var_108) = &input.paste_allowed {
object.key("pasteAllowed").string(var_108.as_str());
}
if let Some(var_109) = &input.print_allowed {
object.key("printAllowed").string(var_109.as_str());
}
if let Some(var_110) = &input.upload_allowed {
object.key("uploadAllowed").string(var_110.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::error::SerializationError> {
if let Some(var_111) = &input.key {
object.key("Key").string(var_111.as_str());
}
if let Some(var_112) = &input.value {
object.key("Value").string(var_112.as_str());
}
Ok(())
}