pub fn serialize_operation_crate_operation_add_client_id_to_open_id_connect_provider(
input: &crate::input::AddClientIdToOpenIdConnectProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"AddClientIDToOpenIDConnectProvider",
"2010-05-08",
);
#[allow(unused_mut)]
let mut scope_1 = writer.prefix("OpenIDConnectProviderArn");
if let Some(var_2) = &input.open_id_connect_provider_arn {
scope_1.string(var_2);
}
#[allow(unused_mut)]
let mut scope_3 = writer.prefix("ClientID");
if let Some(var_4) = &input.client_id {
scope_3.string(var_4);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_add_role_to_instance_profile(
input: &crate::input::AddRoleToInstanceProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AddRoleToInstanceProfile", "2010-05-08");
#[allow(unused_mut)]
let mut scope_5 = writer.prefix("InstanceProfileName");
if let Some(var_6) = &input.instance_profile_name {
scope_5.string(var_6);
}
#[allow(unused_mut)]
let mut scope_7 = writer.prefix("RoleName");
if let Some(var_8) = &input.role_name {
scope_7.string(var_8);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_add_user_to_group(
input: &crate::input::AddUserToGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "AddUserToGroup", "2010-05-08");
#[allow(unused_mut)]
let mut scope_9 = writer.prefix("GroupName");
if let Some(var_10) = &input.group_name {
scope_9.string(var_10);
}
#[allow(unused_mut)]
let mut scope_11 = writer.prefix("UserName");
if let Some(var_12) = &input.user_name {
scope_11.string(var_12);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_attach_group_policy(
input: &crate::input::AttachGroupPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AttachGroupPolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_13 = writer.prefix("GroupName");
if let Some(var_14) = &input.group_name {
scope_13.string(var_14);
}
#[allow(unused_mut)]
let mut scope_15 = writer.prefix("PolicyArn");
if let Some(var_16) = &input.policy_arn {
scope_15.string(var_16);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_attach_role_policy(
input: &crate::input::AttachRolePolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "AttachRolePolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_17 = writer.prefix("RoleName");
if let Some(var_18) = &input.role_name {
scope_17.string(var_18);
}
#[allow(unused_mut)]
let mut scope_19 = writer.prefix("PolicyArn");
if let Some(var_20) = &input.policy_arn {
scope_19.string(var_20);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_attach_user_policy(
input: &crate::input::AttachUserPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "AttachUserPolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_21 = writer.prefix("UserName");
if let Some(var_22) = &input.user_name {
scope_21.string(var_22);
}
#[allow(unused_mut)]
let mut scope_23 = writer.prefix("PolicyArn");
if let Some(var_24) = &input.policy_arn {
scope_23.string(var_24);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_change_password(
input: &crate::input::ChangePasswordInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ChangePassword", "2010-05-08");
#[allow(unused_mut)]
let mut scope_25 = writer.prefix("OldPassword");
if let Some(var_26) = &input.old_password {
scope_25.string(var_26);
}
#[allow(unused_mut)]
let mut scope_27 = writer.prefix("NewPassword");
if let Some(var_28) = &input.new_password {
scope_27.string(var_28);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_access_key(
input: &crate::input::CreateAccessKeyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateAccessKey", "2010-05-08");
#[allow(unused_mut)]
let mut scope_29 = writer.prefix("UserName");
if let Some(var_30) = &input.user_name {
scope_29.string(var_30);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_account_alias(
input: &crate::input::CreateAccountAliasInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateAccountAlias", "2010-05-08");
#[allow(unused_mut)]
let mut scope_31 = writer.prefix("AccountAlias");
if let Some(var_32) = &input.account_alias {
scope_31.string(var_32);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_group(
input: &crate::input::CreateGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateGroup", "2010-05-08");
#[allow(unused_mut)]
let mut scope_33 = writer.prefix("Path");
if let Some(var_34) = &input.path {
scope_33.string(var_34);
}
#[allow(unused_mut)]
let mut scope_35 = writer.prefix("GroupName");
if let Some(var_36) = &input.group_name {
scope_35.string(var_36);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_instance_profile(
input: &crate::input::CreateInstanceProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateInstanceProfile", "2010-05-08");
#[allow(unused_mut)]
let mut scope_37 = writer.prefix("InstanceProfileName");
if let Some(var_38) = &input.instance_profile_name {
scope_37.string(var_38);
}
#[allow(unused_mut)]
let mut scope_39 = writer.prefix("Path");
if let Some(var_40) = &input.path {
scope_39.string(var_40);
}
#[allow(unused_mut)]
let mut scope_41 = writer.prefix("Tags");
if let Some(var_42) = &input.tags {
let mut list_44 = scope_41.start_list(false, None);
for item_43 in var_42 {
#[allow(unused_mut)]
let mut entry_45 = list_44.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_45, item_43)?;
}
list_44.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_login_profile(
input: &crate::input::CreateLoginProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateLoginProfile", "2010-05-08");
#[allow(unused_mut)]
let mut scope_46 = writer.prefix("UserName");
if let Some(var_47) = &input.user_name {
scope_46.string(var_47);
}
#[allow(unused_mut)]
let mut scope_48 = writer.prefix("Password");
if let Some(var_49) = &input.password {
scope_48.string(var_49);
}
#[allow(unused_mut)]
let mut scope_50 = writer.prefix("PasswordResetRequired");
if input.password_reset_required {
scope_50.boolean(input.password_reset_required);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_open_id_connect_provider(
input: &crate::input::CreateOpenIdConnectProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateOpenIDConnectProvider", "2010-05-08");
#[allow(unused_mut)]
let mut scope_51 = writer.prefix("Url");
if let Some(var_52) = &input.url {
scope_51.string(var_52);
}
#[allow(unused_mut)]
let mut scope_53 = writer.prefix("ClientIDList");
if let Some(var_54) = &input.client_id_list {
let mut list_56 = scope_53.start_list(false, None);
for item_55 in var_54 {
#[allow(unused_mut)]
let mut entry_57 = list_56.entry();
entry_57.string(item_55);
}
list_56.finish();
}
#[allow(unused_mut)]
let mut scope_58 = writer.prefix("ThumbprintList");
if let Some(var_59) = &input.thumbprint_list {
let mut list_61 = scope_58.start_list(false, None);
for item_60 in var_59 {
#[allow(unused_mut)]
let mut entry_62 = list_61.entry();
entry_62.string(item_60);
}
list_61.finish();
}
#[allow(unused_mut)]
let mut scope_63 = writer.prefix("Tags");
if let Some(var_64) = &input.tags {
let mut list_66 = scope_63.start_list(false, None);
for item_65 in var_64 {
#[allow(unused_mut)]
let mut entry_67 = list_66.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_67, item_65)?;
}
list_66.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_policy(
input: &crate::input::CreatePolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreatePolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_68 = writer.prefix("PolicyName");
if let Some(var_69) = &input.policy_name {
scope_68.string(var_69);
}
#[allow(unused_mut)]
let mut scope_70 = writer.prefix("Path");
if let Some(var_71) = &input.path {
scope_70.string(var_71);
}
#[allow(unused_mut)]
let mut scope_72 = writer.prefix("PolicyDocument");
if let Some(var_73) = &input.policy_document {
scope_72.string(var_73);
}
#[allow(unused_mut)]
let mut scope_74 = writer.prefix("Description");
if let Some(var_75) = &input.description {
scope_74.string(var_75);
}
#[allow(unused_mut)]
let mut scope_76 = writer.prefix("Tags");
if let Some(var_77) = &input.tags {
let mut list_79 = scope_76.start_list(false, None);
for item_78 in var_77 {
#[allow(unused_mut)]
let mut entry_80 = list_79.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_80, item_78)?;
}
list_79.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_policy_version(
input: &crate::input::CreatePolicyVersionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreatePolicyVersion", "2010-05-08");
#[allow(unused_mut)]
let mut scope_81 = writer.prefix("PolicyArn");
if let Some(var_82) = &input.policy_arn {
scope_81.string(var_82);
}
#[allow(unused_mut)]
let mut scope_83 = writer.prefix("PolicyDocument");
if let Some(var_84) = &input.policy_document {
scope_83.string(var_84);
}
#[allow(unused_mut)]
let mut scope_85 = writer.prefix("SetAsDefault");
if input.set_as_default {
scope_85.boolean(input.set_as_default);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_role(
input: &crate::input::CreateRoleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateRole", "2010-05-08");
#[allow(unused_mut)]
let mut scope_86 = writer.prefix("Path");
if let Some(var_87) = &input.path {
scope_86.string(var_87);
}
#[allow(unused_mut)]
let mut scope_88 = writer.prefix("RoleName");
if let Some(var_89) = &input.role_name {
scope_88.string(var_89);
}
#[allow(unused_mut)]
let mut scope_90 = writer.prefix("AssumeRolePolicyDocument");
if let Some(var_91) = &input.assume_role_policy_document {
scope_90.string(var_91);
}
#[allow(unused_mut)]
let mut scope_92 = writer.prefix("Description");
if let Some(var_93) = &input.description {
scope_92.string(var_93);
}
#[allow(unused_mut)]
let mut scope_94 = writer.prefix("MaxSessionDuration");
if let Some(var_95) = &input.max_session_duration {
scope_94.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_95).into()),
);
}
#[allow(unused_mut)]
let mut scope_96 = writer.prefix("PermissionsBoundary");
if let Some(var_97) = &input.permissions_boundary {
scope_96.string(var_97);
}
#[allow(unused_mut)]
let mut scope_98 = writer.prefix("Tags");
if let Some(var_99) = &input.tags {
let mut list_101 = scope_98.start_list(false, None);
for item_100 in var_99 {
#[allow(unused_mut)]
let mut entry_102 = list_101.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_102, item_100)?;
}
list_101.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_saml_provider(
input: &crate::input::CreateSamlProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateSAMLProvider", "2010-05-08");
#[allow(unused_mut)]
let mut scope_103 = writer.prefix("SAMLMetadataDocument");
if let Some(var_104) = &input.saml_metadata_document {
scope_103.string(var_104);
}
#[allow(unused_mut)]
let mut scope_105 = writer.prefix("Name");
if let Some(var_106) = &input.name {
scope_105.string(var_106);
}
#[allow(unused_mut)]
let mut scope_107 = writer.prefix("Tags");
if let Some(var_108) = &input.tags {
let mut list_110 = scope_107.start_list(false, None);
for item_109 in var_108 {
#[allow(unused_mut)]
let mut entry_111 = list_110.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_111, item_109)?;
}
list_110.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_service_linked_role(
input: &crate::input::CreateServiceLinkedRoleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateServiceLinkedRole", "2010-05-08");
#[allow(unused_mut)]
let mut scope_112 = writer.prefix("AWSServiceName");
if let Some(var_113) = &input.aws_service_name {
scope_112.string(var_113);
}
#[allow(unused_mut)]
let mut scope_114 = writer.prefix("Description");
if let Some(var_115) = &input.description {
scope_114.string(var_115);
}
#[allow(unused_mut)]
let mut scope_116 = writer.prefix("CustomSuffix");
if let Some(var_117) = &input.custom_suffix {
scope_116.string(var_117);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_service_specific_credential(
input: &crate::input::CreateServiceSpecificCredentialInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"CreateServiceSpecificCredential",
"2010-05-08",
);
#[allow(unused_mut)]
let mut scope_118 = writer.prefix("UserName");
if let Some(var_119) = &input.user_name {
scope_118.string(var_119);
}
#[allow(unused_mut)]
let mut scope_120 = writer.prefix("ServiceName");
if let Some(var_121) = &input.service_name {
scope_120.string(var_121);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_user(
input: &crate::input::CreateUserInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateUser", "2010-05-08");
#[allow(unused_mut)]
let mut scope_122 = writer.prefix("Path");
if let Some(var_123) = &input.path {
scope_122.string(var_123);
}
#[allow(unused_mut)]
let mut scope_124 = writer.prefix("UserName");
if let Some(var_125) = &input.user_name {
scope_124.string(var_125);
}
#[allow(unused_mut)]
let mut scope_126 = writer.prefix("PermissionsBoundary");
if let Some(var_127) = &input.permissions_boundary {
scope_126.string(var_127);
}
#[allow(unused_mut)]
let mut scope_128 = writer.prefix("Tags");
if let Some(var_129) = &input.tags {
let mut list_131 = scope_128.start_list(false, None);
for item_130 in var_129 {
#[allow(unused_mut)]
let mut entry_132 = list_131.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_132, item_130)?;
}
list_131.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_virtual_mfa_device(
input: &crate::input::CreateVirtualMfaDeviceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateVirtualMFADevice", "2010-05-08");
#[allow(unused_mut)]
let mut scope_133 = writer.prefix("Path");
if let Some(var_134) = &input.path {
scope_133.string(var_134);
}
#[allow(unused_mut)]
let mut scope_135 = writer.prefix("VirtualMFADeviceName");
if let Some(var_136) = &input.virtual_mfa_device_name {
scope_135.string(var_136);
}
#[allow(unused_mut)]
let mut scope_137 = writer.prefix("Tags");
if let Some(var_138) = &input.tags {
let mut list_140 = scope_137.start_list(false, None);
for item_139 in var_138 {
#[allow(unused_mut)]
let mut entry_141 = list_140.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_141, item_139)?;
}
list_140.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_deactivate_mfa_device(
input: &crate::input::DeactivateMfaDeviceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeactivateMFADevice", "2010-05-08");
#[allow(unused_mut)]
let mut scope_142 = writer.prefix("UserName");
if let Some(var_143) = &input.user_name {
scope_142.string(var_143);
}
#[allow(unused_mut)]
let mut scope_144 = writer.prefix("SerialNumber");
if let Some(var_145) = &input.serial_number {
scope_144.string(var_145);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_access_key(
input: &crate::input::DeleteAccessKeyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteAccessKey", "2010-05-08");
#[allow(unused_mut)]
let mut scope_146 = writer.prefix("UserName");
if let Some(var_147) = &input.user_name {
scope_146.string(var_147);
}
#[allow(unused_mut)]
let mut scope_148 = writer.prefix("AccessKeyId");
if let Some(var_149) = &input.access_key_id {
scope_148.string(var_149);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_account_alias(
input: &crate::input::DeleteAccountAliasInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteAccountAlias", "2010-05-08");
#[allow(unused_mut)]
let mut scope_150 = writer.prefix("AccountAlias");
if let Some(var_151) = &input.account_alias {
scope_150.string(var_151);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_account_password_policy(
input: &crate::input::DeleteAccountPasswordPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let _ = input;
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteAccountPasswordPolicy", "2010-05-08");
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_group(
input: &crate::input::DeleteGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteGroup", "2010-05-08");
#[allow(unused_mut)]
let mut scope_152 = writer.prefix("GroupName");
if let Some(var_153) = &input.group_name {
scope_152.string(var_153);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_group_policy(
input: &crate::input::DeleteGroupPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteGroupPolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_154 = writer.prefix("GroupName");
if let Some(var_155) = &input.group_name {
scope_154.string(var_155);
}
#[allow(unused_mut)]
let mut scope_156 = writer.prefix("PolicyName");
if let Some(var_157) = &input.policy_name {
scope_156.string(var_157);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_instance_profile(
input: &crate::input::DeleteInstanceProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteInstanceProfile", "2010-05-08");
#[allow(unused_mut)]
let mut scope_158 = writer.prefix("InstanceProfileName");
if let Some(var_159) = &input.instance_profile_name {
scope_158.string(var_159);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_login_profile(
input: &crate::input::DeleteLoginProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteLoginProfile", "2010-05-08");
#[allow(unused_mut)]
let mut scope_160 = writer.prefix("UserName");
if let Some(var_161) = &input.user_name {
scope_160.string(var_161);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_open_id_connect_provider(
input: &crate::input::DeleteOpenIdConnectProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteOpenIDConnectProvider", "2010-05-08");
#[allow(unused_mut)]
let mut scope_162 = writer.prefix("OpenIDConnectProviderArn");
if let Some(var_163) = &input.open_id_connect_provider_arn {
scope_162.string(var_163);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_policy(
input: &crate::input::DeletePolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeletePolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_164 = writer.prefix("PolicyArn");
if let Some(var_165) = &input.policy_arn {
scope_164.string(var_165);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_policy_version(
input: &crate::input::DeletePolicyVersionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeletePolicyVersion", "2010-05-08");
#[allow(unused_mut)]
let mut scope_166 = writer.prefix("PolicyArn");
if let Some(var_167) = &input.policy_arn {
scope_166.string(var_167);
}
#[allow(unused_mut)]
let mut scope_168 = writer.prefix("VersionId");
if let Some(var_169) = &input.version_id {
scope_168.string(var_169);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_role(
input: &crate::input::DeleteRoleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteRole", "2010-05-08");
#[allow(unused_mut)]
let mut scope_170 = writer.prefix("RoleName");
if let Some(var_171) = &input.role_name {
scope_170.string(var_171);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_role_permissions_boundary(
input: &crate::input::DeleteRolePermissionsBoundaryInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteRolePermissionsBoundary", "2010-05-08");
#[allow(unused_mut)]
let mut scope_172 = writer.prefix("RoleName");
if let Some(var_173) = &input.role_name {
scope_172.string(var_173);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_role_policy(
input: &crate::input::DeleteRolePolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteRolePolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_174 = writer.prefix("RoleName");
if let Some(var_175) = &input.role_name {
scope_174.string(var_175);
}
#[allow(unused_mut)]
let mut scope_176 = writer.prefix("PolicyName");
if let Some(var_177) = &input.policy_name {
scope_176.string(var_177);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_saml_provider(
input: &crate::input::DeleteSamlProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteSAMLProvider", "2010-05-08");
#[allow(unused_mut)]
let mut scope_178 = writer.prefix("SAMLProviderArn");
if let Some(var_179) = &input.saml_provider_arn {
scope_178.string(var_179);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_server_certificate(
input: &crate::input::DeleteServerCertificateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteServerCertificate", "2010-05-08");
#[allow(unused_mut)]
let mut scope_180 = writer.prefix("ServerCertificateName");
if let Some(var_181) = &input.server_certificate_name {
scope_180.string(var_181);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_service_linked_role(
input: &crate::input::DeleteServiceLinkedRoleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteServiceLinkedRole", "2010-05-08");
#[allow(unused_mut)]
let mut scope_182 = writer.prefix("RoleName");
if let Some(var_183) = &input.role_name {
scope_182.string(var_183);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_service_specific_credential(
input: &crate::input::DeleteServiceSpecificCredentialInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeleteServiceSpecificCredential",
"2010-05-08",
);
#[allow(unused_mut)]
let mut scope_184 = writer.prefix("UserName");
if let Some(var_185) = &input.user_name {
scope_184.string(var_185);
}
#[allow(unused_mut)]
let mut scope_186 = writer.prefix("ServiceSpecificCredentialId");
if let Some(var_187) = &input.service_specific_credential_id {
scope_186.string(var_187);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_signing_certificate(
input: &crate::input::DeleteSigningCertificateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteSigningCertificate", "2010-05-08");
#[allow(unused_mut)]
let mut scope_188 = writer.prefix("UserName");
if let Some(var_189) = &input.user_name {
scope_188.string(var_189);
}
#[allow(unused_mut)]
let mut scope_190 = writer.prefix("CertificateId");
if let Some(var_191) = &input.certificate_id {
scope_190.string(var_191);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_ssh_public_key(
input: &crate::input::DeleteSshPublicKeyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteSSHPublicKey", "2010-05-08");
#[allow(unused_mut)]
let mut scope_192 = writer.prefix("UserName");
if let Some(var_193) = &input.user_name {
scope_192.string(var_193);
}
#[allow(unused_mut)]
let mut scope_194 = writer.prefix("SSHPublicKeyId");
if let Some(var_195) = &input.ssh_public_key_id {
scope_194.string(var_195);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_user(
input: &crate::input::DeleteUserInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteUser", "2010-05-08");
#[allow(unused_mut)]
let mut scope_196 = writer.prefix("UserName");
if let Some(var_197) = &input.user_name {
scope_196.string(var_197);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_user_permissions_boundary(
input: &crate::input::DeleteUserPermissionsBoundaryInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteUserPermissionsBoundary", "2010-05-08");
#[allow(unused_mut)]
let mut scope_198 = writer.prefix("UserName");
if let Some(var_199) = &input.user_name {
scope_198.string(var_199);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_user_policy(
input: &crate::input::DeleteUserPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteUserPolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_200 = writer.prefix("UserName");
if let Some(var_201) = &input.user_name {
scope_200.string(var_201);
}
#[allow(unused_mut)]
let mut scope_202 = writer.prefix("PolicyName");
if let Some(var_203) = &input.policy_name {
scope_202.string(var_203);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_virtual_mfa_device(
input: &crate::input::DeleteVirtualMfaDeviceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteVirtualMFADevice", "2010-05-08");
#[allow(unused_mut)]
let mut scope_204 = writer.prefix("SerialNumber");
if let Some(var_205) = &input.serial_number {
scope_204.string(var_205);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_detach_group_policy(
input: &crate::input::DetachGroupPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DetachGroupPolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_206 = writer.prefix("GroupName");
if let Some(var_207) = &input.group_name {
scope_206.string(var_207);
}
#[allow(unused_mut)]
let mut scope_208 = writer.prefix("PolicyArn");
if let Some(var_209) = &input.policy_arn {
scope_208.string(var_209);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_detach_role_policy(
input: &crate::input::DetachRolePolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DetachRolePolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_210 = writer.prefix("RoleName");
if let Some(var_211) = &input.role_name {
scope_210.string(var_211);
}
#[allow(unused_mut)]
let mut scope_212 = writer.prefix("PolicyArn");
if let Some(var_213) = &input.policy_arn {
scope_212.string(var_213);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_detach_user_policy(
input: &crate::input::DetachUserPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DetachUserPolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_214 = writer.prefix("UserName");
if let Some(var_215) = &input.user_name {
scope_214.string(var_215);
}
#[allow(unused_mut)]
let mut scope_216 = writer.prefix("PolicyArn");
if let Some(var_217) = &input.policy_arn {
scope_216.string(var_217);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_enable_mfa_device(
input: &crate::input::EnableMfaDeviceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "EnableMFADevice", "2010-05-08");
#[allow(unused_mut)]
let mut scope_218 = writer.prefix("UserName");
if let Some(var_219) = &input.user_name {
scope_218.string(var_219);
}
#[allow(unused_mut)]
let mut scope_220 = writer.prefix("SerialNumber");
if let Some(var_221) = &input.serial_number {
scope_220.string(var_221);
}
#[allow(unused_mut)]
let mut scope_222 = writer.prefix("AuthenticationCode1");
if let Some(var_223) = &input.authentication_code1 {
scope_222.string(var_223);
}
#[allow(unused_mut)]
let mut scope_224 = writer.prefix("AuthenticationCode2");
if let Some(var_225) = &input.authentication_code2 {
scope_224.string(var_225);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_generate_credential_report(
input: &crate::input::GenerateCredentialReportInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let _ = input;
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GenerateCredentialReport", "2010-05-08");
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_generate_organizations_access_report(
input: &crate::input::GenerateOrganizationsAccessReportInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GenerateOrganizationsAccessReport",
"2010-05-08",
);
#[allow(unused_mut)]
let mut scope_226 = writer.prefix("EntityPath");
if let Some(var_227) = &input.entity_path {
scope_226.string(var_227);
}
#[allow(unused_mut)]
let mut scope_228 = writer.prefix("OrganizationsPolicyId");
if let Some(var_229) = &input.organizations_policy_id {
scope_228.string(var_229);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_generate_service_last_accessed_details(
input: &crate::input::GenerateServiceLastAccessedDetailsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GenerateServiceLastAccessedDetails",
"2010-05-08",
);
#[allow(unused_mut)]
let mut scope_230 = writer.prefix("Arn");
if let Some(var_231) = &input.arn {
scope_230.string(var_231);
}
#[allow(unused_mut)]
let mut scope_232 = writer.prefix("Granularity");
if let Some(var_233) = &input.granularity {
scope_232.string(var_233.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_access_key_last_used(
input: &crate::input::GetAccessKeyLastUsedInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetAccessKeyLastUsed", "2010-05-08");
#[allow(unused_mut)]
let mut scope_234 = writer.prefix("AccessKeyId");
if let Some(var_235) = &input.access_key_id {
scope_234.string(var_235);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_account_authorization_details(
input: &crate::input::GetAccountAuthorizationDetailsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetAccountAuthorizationDetails",
"2010-05-08",
);
#[allow(unused_mut)]
let mut scope_236 = writer.prefix("Filter");
if let Some(var_237) = &input.filter {
let mut list_239 = scope_236.start_list(false, None);
for item_238 in var_237 {
#[allow(unused_mut)]
let mut entry_240 = list_239.entry();
entry_240.string(item_238.as_str());
}
list_239.finish();
}
#[allow(unused_mut)]
let mut scope_241 = writer.prefix("MaxItems");
if let Some(var_242) = &input.max_items {
scope_241.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_242).into()),
);
}
#[allow(unused_mut)]
let mut scope_243 = writer.prefix("Marker");
if let Some(var_244) = &input.marker {
scope_243.string(var_244);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_account_password_policy(
input: &crate::input::GetAccountPasswordPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let _ = input;
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetAccountPasswordPolicy", "2010-05-08");
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_account_summary(
input: &crate::input::GetAccountSummaryInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let _ = input;
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetAccountSummary", "2010-05-08");
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_context_keys_for_custom_policy(
input: &crate::input::GetContextKeysForCustomPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetContextKeysForCustomPolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_245 = writer.prefix("PolicyInputList");
if let Some(var_246) = &input.policy_input_list {
let mut list_248 = scope_245.start_list(false, None);
for item_247 in var_246 {
#[allow(unused_mut)]
let mut entry_249 = list_248.entry();
entry_249.string(item_247);
}
list_248.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_context_keys_for_principal_policy(
input: &crate::input::GetContextKeysForPrincipalPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetContextKeysForPrincipalPolicy",
"2010-05-08",
);
#[allow(unused_mut)]
let mut scope_250 = writer.prefix("PolicySourceArn");
if let Some(var_251) = &input.policy_source_arn {
scope_250.string(var_251);
}
#[allow(unused_mut)]
let mut scope_252 = writer.prefix("PolicyInputList");
if let Some(var_253) = &input.policy_input_list {
let mut list_255 = scope_252.start_list(false, None);
for item_254 in var_253 {
#[allow(unused_mut)]
let mut entry_256 = list_255.entry();
entry_256.string(item_254);
}
list_255.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_credential_report(
input: &crate::input::GetCredentialReportInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let _ = input;
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetCredentialReport", "2010-05-08");
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_group(
input: &crate::input::GetGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetGroup", "2010-05-08");
#[allow(unused_mut)]
let mut scope_257 = writer.prefix("GroupName");
if let Some(var_258) = &input.group_name {
scope_257.string(var_258);
}
#[allow(unused_mut)]
let mut scope_259 = writer.prefix("Marker");
if let Some(var_260) = &input.marker {
scope_259.string(var_260);
}
#[allow(unused_mut)]
let mut scope_261 = writer.prefix("MaxItems");
if let Some(var_262) = &input.max_items {
scope_261.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_262).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_group_policy(
input: &crate::input::GetGroupPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetGroupPolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_263 = writer.prefix("GroupName");
if let Some(var_264) = &input.group_name {
scope_263.string(var_264);
}
#[allow(unused_mut)]
let mut scope_265 = writer.prefix("PolicyName");
if let Some(var_266) = &input.policy_name {
scope_265.string(var_266);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_instance_profile(
input: &crate::input::GetInstanceProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetInstanceProfile", "2010-05-08");
#[allow(unused_mut)]
let mut scope_267 = writer.prefix("InstanceProfileName");
if let Some(var_268) = &input.instance_profile_name {
scope_267.string(var_268);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_login_profile(
input: &crate::input::GetLoginProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetLoginProfile", "2010-05-08");
#[allow(unused_mut)]
let mut scope_269 = writer.prefix("UserName");
if let Some(var_270) = &input.user_name {
scope_269.string(var_270);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_open_id_connect_provider(
input: &crate::input::GetOpenIdConnectProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetOpenIDConnectProvider", "2010-05-08");
#[allow(unused_mut)]
let mut scope_271 = writer.prefix("OpenIDConnectProviderArn");
if let Some(var_272) = &input.open_id_connect_provider_arn {
scope_271.string(var_272);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_organizations_access_report(
input: &crate::input::GetOrganizationsAccessReportInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetOrganizationsAccessReport", "2010-05-08");
#[allow(unused_mut)]
let mut scope_273 = writer.prefix("JobId");
if let Some(var_274) = &input.job_id {
scope_273.string(var_274);
}
#[allow(unused_mut)]
let mut scope_275 = writer.prefix("MaxItems");
if let Some(var_276) = &input.max_items {
scope_275.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_276).into()),
);
}
#[allow(unused_mut)]
let mut scope_277 = writer.prefix("Marker");
if let Some(var_278) = &input.marker {
scope_277.string(var_278);
}
#[allow(unused_mut)]
let mut scope_279 = writer.prefix("SortKey");
if let Some(var_280) = &input.sort_key {
scope_279.string(var_280.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_policy(
input: &crate::input::GetPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetPolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_281 = writer.prefix("PolicyArn");
if let Some(var_282) = &input.policy_arn {
scope_281.string(var_282);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_policy_version(
input: &crate::input::GetPolicyVersionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetPolicyVersion", "2010-05-08");
#[allow(unused_mut)]
let mut scope_283 = writer.prefix("PolicyArn");
if let Some(var_284) = &input.policy_arn {
scope_283.string(var_284);
}
#[allow(unused_mut)]
let mut scope_285 = writer.prefix("VersionId");
if let Some(var_286) = &input.version_id {
scope_285.string(var_286);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_role(
input: &crate::input::GetRoleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetRole", "2010-05-08");
#[allow(unused_mut)]
let mut scope_287 = writer.prefix("RoleName");
if let Some(var_288) = &input.role_name {
scope_287.string(var_288);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_role_policy(
input: &crate::input::GetRolePolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetRolePolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_289 = writer.prefix("RoleName");
if let Some(var_290) = &input.role_name {
scope_289.string(var_290);
}
#[allow(unused_mut)]
let mut scope_291 = writer.prefix("PolicyName");
if let Some(var_292) = &input.policy_name {
scope_291.string(var_292);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_saml_provider(
input: &crate::input::GetSamlProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetSAMLProvider", "2010-05-08");
#[allow(unused_mut)]
let mut scope_293 = writer.prefix("SAMLProviderArn");
if let Some(var_294) = &input.saml_provider_arn {
scope_293.string(var_294);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_server_certificate(
input: &crate::input::GetServerCertificateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetServerCertificate", "2010-05-08");
#[allow(unused_mut)]
let mut scope_295 = writer.prefix("ServerCertificateName");
if let Some(var_296) = &input.server_certificate_name {
scope_295.string(var_296);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_service_last_accessed_details(
input: &crate::input::GetServiceLastAccessedDetailsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetServiceLastAccessedDetails", "2010-05-08");
#[allow(unused_mut)]
let mut scope_297 = writer.prefix("JobId");
if let Some(var_298) = &input.job_id {
scope_297.string(var_298);
}
#[allow(unused_mut)]
let mut scope_299 = writer.prefix("MaxItems");
if let Some(var_300) = &input.max_items {
scope_299.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_300).into()),
);
}
#[allow(unused_mut)]
let mut scope_301 = writer.prefix("Marker");
if let Some(var_302) = &input.marker {
scope_301.string(var_302);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_service_last_accessed_details_with_entities(
input: &crate::input::GetServiceLastAccessedDetailsWithEntitiesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetServiceLastAccessedDetailsWithEntities",
"2010-05-08",
);
#[allow(unused_mut)]
let mut scope_303 = writer.prefix("JobId");
if let Some(var_304) = &input.job_id {
scope_303.string(var_304);
}
#[allow(unused_mut)]
let mut scope_305 = writer.prefix("ServiceNamespace");
if let Some(var_306) = &input.service_namespace {
scope_305.string(var_306);
}
#[allow(unused_mut)]
let mut scope_307 = writer.prefix("MaxItems");
if let Some(var_308) = &input.max_items {
scope_307.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_308).into()),
);
}
#[allow(unused_mut)]
let mut scope_309 = writer.prefix("Marker");
if let Some(var_310) = &input.marker {
scope_309.string(var_310);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_service_linked_role_deletion_status(
input: &crate::input::GetServiceLinkedRoleDeletionStatusInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetServiceLinkedRoleDeletionStatus",
"2010-05-08",
);
#[allow(unused_mut)]
let mut scope_311 = writer.prefix("DeletionTaskId");
if let Some(var_312) = &input.deletion_task_id {
scope_311.string(var_312);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_ssh_public_key(
input: &crate::input::GetSshPublicKeyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetSSHPublicKey", "2010-05-08");
#[allow(unused_mut)]
let mut scope_313 = writer.prefix("UserName");
if let Some(var_314) = &input.user_name {
scope_313.string(var_314);
}
#[allow(unused_mut)]
let mut scope_315 = writer.prefix("SSHPublicKeyId");
if let Some(var_316) = &input.ssh_public_key_id {
scope_315.string(var_316);
}
#[allow(unused_mut)]
let mut scope_317 = writer.prefix("Encoding");
if let Some(var_318) = &input.encoding {
scope_317.string(var_318.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_user(
input: &crate::input::GetUserInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetUser", "2010-05-08");
#[allow(unused_mut)]
let mut scope_319 = writer.prefix("UserName");
if let Some(var_320) = &input.user_name {
scope_319.string(var_320);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_user_policy(
input: &crate::input::GetUserPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetUserPolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_321 = writer.prefix("UserName");
if let Some(var_322) = &input.user_name {
scope_321.string(var_322);
}
#[allow(unused_mut)]
let mut scope_323 = writer.prefix("PolicyName");
if let Some(var_324) = &input.policy_name {
scope_323.string(var_324);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_access_keys(
input: &crate::input::ListAccessKeysInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListAccessKeys", "2010-05-08");
#[allow(unused_mut)]
let mut scope_325 = writer.prefix("UserName");
if let Some(var_326) = &input.user_name {
scope_325.string(var_326);
}
#[allow(unused_mut)]
let mut scope_327 = writer.prefix("Marker");
if let Some(var_328) = &input.marker {
scope_327.string(var_328);
}
#[allow(unused_mut)]
let mut scope_329 = writer.prefix("MaxItems");
if let Some(var_330) = &input.max_items {
scope_329.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_330).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_account_aliases(
input: &crate::input::ListAccountAliasesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListAccountAliases", "2010-05-08");
#[allow(unused_mut)]
let mut scope_331 = writer.prefix("Marker");
if let Some(var_332) = &input.marker {
scope_331.string(var_332);
}
#[allow(unused_mut)]
let mut scope_333 = writer.prefix("MaxItems");
if let Some(var_334) = &input.max_items {
scope_333.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_334).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_attached_group_policies(
input: &crate::input::ListAttachedGroupPoliciesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListAttachedGroupPolicies", "2010-05-08");
#[allow(unused_mut)]
let mut scope_335 = writer.prefix("GroupName");
if let Some(var_336) = &input.group_name {
scope_335.string(var_336);
}
#[allow(unused_mut)]
let mut scope_337 = writer.prefix("PathPrefix");
if let Some(var_338) = &input.path_prefix {
scope_337.string(var_338);
}
#[allow(unused_mut)]
let mut scope_339 = writer.prefix("Marker");
if let Some(var_340) = &input.marker {
scope_339.string(var_340);
}
#[allow(unused_mut)]
let mut scope_341 = writer.prefix("MaxItems");
if let Some(var_342) = &input.max_items {
scope_341.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_342).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_attached_role_policies(
input: &crate::input::ListAttachedRolePoliciesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListAttachedRolePolicies", "2010-05-08");
#[allow(unused_mut)]
let mut scope_343 = writer.prefix("RoleName");
if let Some(var_344) = &input.role_name {
scope_343.string(var_344);
}
#[allow(unused_mut)]
let mut scope_345 = writer.prefix("PathPrefix");
if let Some(var_346) = &input.path_prefix {
scope_345.string(var_346);
}
#[allow(unused_mut)]
let mut scope_347 = writer.prefix("Marker");
if let Some(var_348) = &input.marker {
scope_347.string(var_348);
}
#[allow(unused_mut)]
let mut scope_349 = writer.prefix("MaxItems");
if let Some(var_350) = &input.max_items {
scope_349.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_350).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_attached_user_policies(
input: &crate::input::ListAttachedUserPoliciesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListAttachedUserPolicies", "2010-05-08");
#[allow(unused_mut)]
let mut scope_351 = writer.prefix("UserName");
if let Some(var_352) = &input.user_name {
scope_351.string(var_352);
}
#[allow(unused_mut)]
let mut scope_353 = writer.prefix("PathPrefix");
if let Some(var_354) = &input.path_prefix {
scope_353.string(var_354);
}
#[allow(unused_mut)]
let mut scope_355 = writer.prefix("Marker");
if let Some(var_356) = &input.marker {
scope_355.string(var_356);
}
#[allow(unused_mut)]
let mut scope_357 = writer.prefix("MaxItems");
if let Some(var_358) = &input.max_items {
scope_357.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_358).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_entities_for_policy(
input: &crate::input::ListEntitiesForPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListEntitiesForPolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_359 = writer.prefix("PolicyArn");
if let Some(var_360) = &input.policy_arn {
scope_359.string(var_360);
}
#[allow(unused_mut)]
let mut scope_361 = writer.prefix("EntityFilter");
if let Some(var_362) = &input.entity_filter {
scope_361.string(var_362.as_str());
}
#[allow(unused_mut)]
let mut scope_363 = writer.prefix("PathPrefix");
if let Some(var_364) = &input.path_prefix {
scope_363.string(var_364);
}
#[allow(unused_mut)]
let mut scope_365 = writer.prefix("PolicyUsageFilter");
if let Some(var_366) = &input.policy_usage_filter {
scope_365.string(var_366.as_str());
}
#[allow(unused_mut)]
let mut scope_367 = writer.prefix("Marker");
if let Some(var_368) = &input.marker {
scope_367.string(var_368);
}
#[allow(unused_mut)]
let mut scope_369 = writer.prefix("MaxItems");
if let Some(var_370) = &input.max_items {
scope_369.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_370).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_group_policies(
input: &crate::input::ListGroupPoliciesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListGroupPolicies", "2010-05-08");
#[allow(unused_mut)]
let mut scope_371 = writer.prefix("GroupName");
if let Some(var_372) = &input.group_name {
scope_371.string(var_372);
}
#[allow(unused_mut)]
let mut scope_373 = writer.prefix("Marker");
if let Some(var_374) = &input.marker {
scope_373.string(var_374);
}
#[allow(unused_mut)]
let mut scope_375 = writer.prefix("MaxItems");
if let Some(var_376) = &input.max_items {
scope_375.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_376).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_groups(
input: &crate::input::ListGroupsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListGroups", "2010-05-08");
#[allow(unused_mut)]
let mut scope_377 = writer.prefix("PathPrefix");
if let Some(var_378) = &input.path_prefix {
scope_377.string(var_378);
}
#[allow(unused_mut)]
let mut scope_379 = writer.prefix("Marker");
if let Some(var_380) = &input.marker {
scope_379.string(var_380);
}
#[allow(unused_mut)]
let mut scope_381 = writer.prefix("MaxItems");
if let Some(var_382) = &input.max_items {
scope_381.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_382).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_groups_for_user(
input: &crate::input::ListGroupsForUserInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListGroupsForUser", "2010-05-08");
#[allow(unused_mut)]
let mut scope_383 = writer.prefix("UserName");
if let Some(var_384) = &input.user_name {
scope_383.string(var_384);
}
#[allow(unused_mut)]
let mut scope_385 = writer.prefix("Marker");
if let Some(var_386) = &input.marker {
scope_385.string(var_386);
}
#[allow(unused_mut)]
let mut scope_387 = writer.prefix("MaxItems");
if let Some(var_388) = &input.max_items {
scope_387.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_388).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_instance_profiles(
input: &crate::input::ListInstanceProfilesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListInstanceProfiles", "2010-05-08");
#[allow(unused_mut)]
let mut scope_389 = writer.prefix("PathPrefix");
if let Some(var_390) = &input.path_prefix {
scope_389.string(var_390);
}
#[allow(unused_mut)]
let mut scope_391 = writer.prefix("Marker");
if let Some(var_392) = &input.marker {
scope_391.string(var_392);
}
#[allow(unused_mut)]
let mut scope_393 = writer.prefix("MaxItems");
if let Some(var_394) = &input.max_items {
scope_393.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_394).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_instance_profiles_for_role(
input: &crate::input::ListInstanceProfilesForRoleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListInstanceProfilesForRole", "2010-05-08");
#[allow(unused_mut)]
let mut scope_395 = writer.prefix("RoleName");
if let Some(var_396) = &input.role_name {
scope_395.string(var_396);
}
#[allow(unused_mut)]
let mut scope_397 = writer.prefix("Marker");
if let Some(var_398) = &input.marker {
scope_397.string(var_398);
}
#[allow(unused_mut)]
let mut scope_399 = writer.prefix("MaxItems");
if let Some(var_400) = &input.max_items {
scope_399.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_400).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_instance_profile_tags(
input: &crate::input::ListInstanceProfileTagsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListInstanceProfileTags", "2010-05-08");
#[allow(unused_mut)]
let mut scope_401 = writer.prefix("InstanceProfileName");
if let Some(var_402) = &input.instance_profile_name {
scope_401.string(var_402);
}
#[allow(unused_mut)]
let mut scope_403 = writer.prefix("Marker");
if let Some(var_404) = &input.marker {
scope_403.string(var_404);
}
#[allow(unused_mut)]
let mut scope_405 = writer.prefix("MaxItems");
if let Some(var_406) = &input.max_items {
scope_405.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_406).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_mfa_devices(
input: &crate::input::ListMfaDevicesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListMFADevices", "2010-05-08");
#[allow(unused_mut)]
let mut scope_407 = writer.prefix("UserName");
if let Some(var_408) = &input.user_name {
scope_407.string(var_408);
}
#[allow(unused_mut)]
let mut scope_409 = writer.prefix("Marker");
if let Some(var_410) = &input.marker {
scope_409.string(var_410);
}
#[allow(unused_mut)]
let mut scope_411 = writer.prefix("MaxItems");
if let Some(var_412) = &input.max_items {
scope_411.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_412).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_mfa_device_tags(
input: &crate::input::ListMfaDeviceTagsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListMFADeviceTags", "2010-05-08");
#[allow(unused_mut)]
let mut scope_413 = writer.prefix("SerialNumber");
if let Some(var_414) = &input.serial_number {
scope_413.string(var_414);
}
#[allow(unused_mut)]
let mut scope_415 = writer.prefix("Marker");
if let Some(var_416) = &input.marker {
scope_415.string(var_416);
}
#[allow(unused_mut)]
let mut scope_417 = writer.prefix("MaxItems");
if let Some(var_418) = &input.max_items {
scope_417.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_418).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_open_id_connect_providers(
input: &crate::input::ListOpenIdConnectProvidersInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let _ = input;
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListOpenIDConnectProviders", "2010-05-08");
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_open_id_connect_provider_tags(
input: &crate::input::ListOpenIdConnectProviderTagsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListOpenIDConnectProviderTags", "2010-05-08");
#[allow(unused_mut)]
let mut scope_419 = writer.prefix("OpenIDConnectProviderArn");
if let Some(var_420) = &input.open_id_connect_provider_arn {
scope_419.string(var_420);
}
#[allow(unused_mut)]
let mut scope_421 = writer.prefix("Marker");
if let Some(var_422) = &input.marker {
scope_421.string(var_422);
}
#[allow(unused_mut)]
let mut scope_423 = writer.prefix("MaxItems");
if let Some(var_424) = &input.max_items {
scope_423.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_424).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_policies(
input: &crate::input::ListPoliciesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListPolicies", "2010-05-08");
#[allow(unused_mut)]
let mut scope_425 = writer.prefix("Scope");
if let Some(var_426) = &input.scope {
scope_425.string(var_426.as_str());
}
#[allow(unused_mut)]
let mut scope_427 = writer.prefix("OnlyAttached");
if input.only_attached {
scope_427.boolean(input.only_attached);
}
#[allow(unused_mut)]
let mut scope_428 = writer.prefix("PathPrefix");
if let Some(var_429) = &input.path_prefix {
scope_428.string(var_429);
}
#[allow(unused_mut)]
let mut scope_430 = writer.prefix("PolicyUsageFilter");
if let Some(var_431) = &input.policy_usage_filter {
scope_430.string(var_431.as_str());
}
#[allow(unused_mut)]
let mut scope_432 = writer.prefix("Marker");
if let Some(var_433) = &input.marker {
scope_432.string(var_433);
}
#[allow(unused_mut)]
let mut scope_434 = writer.prefix("MaxItems");
if let Some(var_435) = &input.max_items {
scope_434.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_435).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_policies_granting_service_access(
input: &crate::input::ListPoliciesGrantingServiceAccessInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ListPoliciesGrantingServiceAccess",
"2010-05-08",
);
#[allow(unused_mut)]
let mut scope_436 = writer.prefix("Marker");
if let Some(var_437) = &input.marker {
scope_436.string(var_437);
}
#[allow(unused_mut)]
let mut scope_438 = writer.prefix("Arn");
if let Some(var_439) = &input.arn {
scope_438.string(var_439);
}
#[allow(unused_mut)]
let mut scope_440 = writer.prefix("ServiceNamespaces");
if let Some(var_441) = &input.service_namespaces {
let mut list_443 = scope_440.start_list(false, None);
for item_442 in var_441 {
#[allow(unused_mut)]
let mut entry_444 = list_443.entry();
entry_444.string(item_442);
}
list_443.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_policy_tags(
input: &crate::input::ListPolicyTagsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListPolicyTags", "2010-05-08");
#[allow(unused_mut)]
let mut scope_445 = writer.prefix("PolicyArn");
if let Some(var_446) = &input.policy_arn {
scope_445.string(var_446);
}
#[allow(unused_mut)]
let mut scope_447 = writer.prefix("Marker");
if let Some(var_448) = &input.marker {
scope_447.string(var_448);
}
#[allow(unused_mut)]
let mut scope_449 = writer.prefix("MaxItems");
if let Some(var_450) = &input.max_items {
scope_449.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_450).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_policy_versions(
input: &crate::input::ListPolicyVersionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListPolicyVersions", "2010-05-08");
#[allow(unused_mut)]
let mut scope_451 = writer.prefix("PolicyArn");
if let Some(var_452) = &input.policy_arn {
scope_451.string(var_452);
}
#[allow(unused_mut)]
let mut scope_453 = writer.prefix("Marker");
if let Some(var_454) = &input.marker {
scope_453.string(var_454);
}
#[allow(unused_mut)]
let mut scope_455 = writer.prefix("MaxItems");
if let Some(var_456) = &input.max_items {
scope_455.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_456).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_role_policies(
input: &crate::input::ListRolePoliciesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListRolePolicies", "2010-05-08");
#[allow(unused_mut)]
let mut scope_457 = writer.prefix("RoleName");
if let Some(var_458) = &input.role_name {
scope_457.string(var_458);
}
#[allow(unused_mut)]
let mut scope_459 = writer.prefix("Marker");
if let Some(var_460) = &input.marker {
scope_459.string(var_460);
}
#[allow(unused_mut)]
let mut scope_461 = writer.prefix("MaxItems");
if let Some(var_462) = &input.max_items {
scope_461.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_462).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_roles(
input: &crate::input::ListRolesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListRoles", "2010-05-08");
#[allow(unused_mut)]
let mut scope_463 = writer.prefix("PathPrefix");
if let Some(var_464) = &input.path_prefix {
scope_463.string(var_464);
}
#[allow(unused_mut)]
let mut scope_465 = writer.prefix("Marker");
if let Some(var_466) = &input.marker {
scope_465.string(var_466);
}
#[allow(unused_mut)]
let mut scope_467 = writer.prefix("MaxItems");
if let Some(var_468) = &input.max_items {
scope_467.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_468).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_role_tags(
input: &crate::input::ListRoleTagsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListRoleTags", "2010-05-08");
#[allow(unused_mut)]
let mut scope_469 = writer.prefix("RoleName");
if let Some(var_470) = &input.role_name {
scope_469.string(var_470);
}
#[allow(unused_mut)]
let mut scope_471 = writer.prefix("Marker");
if let Some(var_472) = &input.marker {
scope_471.string(var_472);
}
#[allow(unused_mut)]
let mut scope_473 = writer.prefix("MaxItems");
if let Some(var_474) = &input.max_items {
scope_473.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_474).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_saml_providers(
input: &crate::input::ListSamlProvidersInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let _ = input;
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListSAMLProviders", "2010-05-08");
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_saml_provider_tags(
input: &crate::input::ListSamlProviderTagsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListSAMLProviderTags", "2010-05-08");
#[allow(unused_mut)]
let mut scope_475 = writer.prefix("SAMLProviderArn");
if let Some(var_476) = &input.saml_provider_arn {
scope_475.string(var_476);
}
#[allow(unused_mut)]
let mut scope_477 = writer.prefix("Marker");
if let Some(var_478) = &input.marker {
scope_477.string(var_478);
}
#[allow(unused_mut)]
let mut scope_479 = writer.prefix("MaxItems");
if let Some(var_480) = &input.max_items {
scope_479.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_480).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_server_certificates(
input: &crate::input::ListServerCertificatesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListServerCertificates", "2010-05-08");
#[allow(unused_mut)]
let mut scope_481 = writer.prefix("PathPrefix");
if let Some(var_482) = &input.path_prefix {
scope_481.string(var_482);
}
#[allow(unused_mut)]
let mut scope_483 = writer.prefix("Marker");
if let Some(var_484) = &input.marker {
scope_483.string(var_484);
}
#[allow(unused_mut)]
let mut scope_485 = writer.prefix("MaxItems");
if let Some(var_486) = &input.max_items {
scope_485.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_486).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_server_certificate_tags(
input: &crate::input::ListServerCertificateTagsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListServerCertificateTags", "2010-05-08");
#[allow(unused_mut)]
let mut scope_487 = writer.prefix("ServerCertificateName");
if let Some(var_488) = &input.server_certificate_name {
scope_487.string(var_488);
}
#[allow(unused_mut)]
let mut scope_489 = writer.prefix("Marker");
if let Some(var_490) = &input.marker {
scope_489.string(var_490);
}
#[allow(unused_mut)]
let mut scope_491 = writer.prefix("MaxItems");
if let Some(var_492) = &input.max_items {
scope_491.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_492).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_service_specific_credentials(
input: &crate::input::ListServiceSpecificCredentialsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ListServiceSpecificCredentials",
"2010-05-08",
);
#[allow(unused_mut)]
let mut scope_493 = writer.prefix("UserName");
if let Some(var_494) = &input.user_name {
scope_493.string(var_494);
}
#[allow(unused_mut)]
let mut scope_495 = writer.prefix("ServiceName");
if let Some(var_496) = &input.service_name {
scope_495.string(var_496);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_signing_certificates(
input: &crate::input::ListSigningCertificatesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListSigningCertificates", "2010-05-08");
#[allow(unused_mut)]
let mut scope_497 = writer.prefix("UserName");
if let Some(var_498) = &input.user_name {
scope_497.string(var_498);
}
#[allow(unused_mut)]
let mut scope_499 = writer.prefix("Marker");
if let Some(var_500) = &input.marker {
scope_499.string(var_500);
}
#[allow(unused_mut)]
let mut scope_501 = writer.prefix("MaxItems");
if let Some(var_502) = &input.max_items {
scope_501.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_502).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_ssh_public_keys(
input: &crate::input::ListSshPublicKeysInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListSSHPublicKeys", "2010-05-08");
#[allow(unused_mut)]
let mut scope_503 = writer.prefix("UserName");
if let Some(var_504) = &input.user_name {
scope_503.string(var_504);
}
#[allow(unused_mut)]
let mut scope_505 = writer.prefix("Marker");
if let Some(var_506) = &input.marker {
scope_505.string(var_506);
}
#[allow(unused_mut)]
let mut scope_507 = writer.prefix("MaxItems");
if let Some(var_508) = &input.max_items {
scope_507.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_508).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_user_policies(
input: &crate::input::ListUserPoliciesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListUserPolicies", "2010-05-08");
#[allow(unused_mut)]
let mut scope_509 = writer.prefix("UserName");
if let Some(var_510) = &input.user_name {
scope_509.string(var_510);
}
#[allow(unused_mut)]
let mut scope_511 = writer.prefix("Marker");
if let Some(var_512) = &input.marker {
scope_511.string(var_512);
}
#[allow(unused_mut)]
let mut scope_513 = writer.prefix("MaxItems");
if let Some(var_514) = &input.max_items {
scope_513.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_514).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_users(
input: &crate::input::ListUsersInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListUsers", "2010-05-08");
#[allow(unused_mut)]
let mut scope_515 = writer.prefix("PathPrefix");
if let Some(var_516) = &input.path_prefix {
scope_515.string(var_516);
}
#[allow(unused_mut)]
let mut scope_517 = writer.prefix("Marker");
if let Some(var_518) = &input.marker {
scope_517.string(var_518);
}
#[allow(unused_mut)]
let mut scope_519 = writer.prefix("MaxItems");
if let Some(var_520) = &input.max_items {
scope_519.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_520).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_user_tags(
input: &crate::input::ListUserTagsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListUserTags", "2010-05-08");
#[allow(unused_mut)]
let mut scope_521 = writer.prefix("UserName");
if let Some(var_522) = &input.user_name {
scope_521.string(var_522);
}
#[allow(unused_mut)]
let mut scope_523 = writer.prefix("Marker");
if let Some(var_524) = &input.marker {
scope_523.string(var_524);
}
#[allow(unused_mut)]
let mut scope_525 = writer.prefix("MaxItems");
if let Some(var_526) = &input.max_items {
scope_525.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_526).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_virtual_mfa_devices(
input: &crate::input::ListVirtualMfaDevicesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListVirtualMFADevices", "2010-05-08");
#[allow(unused_mut)]
let mut scope_527 = writer.prefix("AssignmentStatus");
if let Some(var_528) = &input.assignment_status {
scope_527.string(var_528.as_str());
}
#[allow(unused_mut)]
let mut scope_529 = writer.prefix("Marker");
if let Some(var_530) = &input.marker {
scope_529.string(var_530);
}
#[allow(unused_mut)]
let mut scope_531 = writer.prefix("MaxItems");
if let Some(var_532) = &input.max_items {
scope_531.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_532).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_put_group_policy(
input: &crate::input::PutGroupPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "PutGroupPolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_533 = writer.prefix("GroupName");
if let Some(var_534) = &input.group_name {
scope_533.string(var_534);
}
#[allow(unused_mut)]
let mut scope_535 = writer.prefix("PolicyName");
if let Some(var_536) = &input.policy_name {
scope_535.string(var_536);
}
#[allow(unused_mut)]
let mut scope_537 = writer.prefix("PolicyDocument");
if let Some(var_538) = &input.policy_document {
scope_537.string(var_538);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_put_role_permissions_boundary(
input: &crate::input::PutRolePermissionsBoundaryInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "PutRolePermissionsBoundary", "2010-05-08");
#[allow(unused_mut)]
let mut scope_539 = writer.prefix("RoleName");
if let Some(var_540) = &input.role_name {
scope_539.string(var_540);
}
#[allow(unused_mut)]
let mut scope_541 = writer.prefix("PermissionsBoundary");
if let Some(var_542) = &input.permissions_boundary {
scope_541.string(var_542);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_put_role_policy(
input: &crate::input::PutRolePolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "PutRolePolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_543 = writer.prefix("RoleName");
if let Some(var_544) = &input.role_name {
scope_543.string(var_544);
}
#[allow(unused_mut)]
let mut scope_545 = writer.prefix("PolicyName");
if let Some(var_546) = &input.policy_name {
scope_545.string(var_546);
}
#[allow(unused_mut)]
let mut scope_547 = writer.prefix("PolicyDocument");
if let Some(var_548) = &input.policy_document {
scope_547.string(var_548);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_put_user_permissions_boundary(
input: &crate::input::PutUserPermissionsBoundaryInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "PutUserPermissionsBoundary", "2010-05-08");
#[allow(unused_mut)]
let mut scope_549 = writer.prefix("UserName");
if let Some(var_550) = &input.user_name {
scope_549.string(var_550);
}
#[allow(unused_mut)]
let mut scope_551 = writer.prefix("PermissionsBoundary");
if let Some(var_552) = &input.permissions_boundary {
scope_551.string(var_552);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_put_user_policy(
input: &crate::input::PutUserPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "PutUserPolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_553 = writer.prefix("UserName");
if let Some(var_554) = &input.user_name {
scope_553.string(var_554);
}
#[allow(unused_mut)]
let mut scope_555 = writer.prefix("PolicyName");
if let Some(var_556) = &input.policy_name {
scope_555.string(var_556);
}
#[allow(unused_mut)]
let mut scope_557 = writer.prefix("PolicyDocument");
if let Some(var_558) = &input.policy_document {
scope_557.string(var_558);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_remove_client_id_from_open_id_connect_provider(
input: &crate::input::RemoveClientIdFromOpenIdConnectProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"RemoveClientIDFromOpenIDConnectProvider",
"2010-05-08",
);
#[allow(unused_mut)]
let mut scope_559 = writer.prefix("OpenIDConnectProviderArn");
if let Some(var_560) = &input.open_id_connect_provider_arn {
scope_559.string(var_560);
}
#[allow(unused_mut)]
let mut scope_561 = writer.prefix("ClientID");
if let Some(var_562) = &input.client_id {
scope_561.string(var_562);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_remove_role_from_instance_profile(
input: &crate::input::RemoveRoleFromInstanceProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RemoveRoleFromInstanceProfile", "2010-05-08");
#[allow(unused_mut)]
let mut scope_563 = writer.prefix("InstanceProfileName");
if let Some(var_564) = &input.instance_profile_name {
scope_563.string(var_564);
}
#[allow(unused_mut)]
let mut scope_565 = writer.prefix("RoleName");
if let Some(var_566) = &input.role_name {
scope_565.string(var_566);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_remove_user_from_group(
input: &crate::input::RemoveUserFromGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RemoveUserFromGroup", "2010-05-08");
#[allow(unused_mut)]
let mut scope_567 = writer.prefix("GroupName");
if let Some(var_568) = &input.group_name {
scope_567.string(var_568);
}
#[allow(unused_mut)]
let mut scope_569 = writer.prefix("UserName");
if let Some(var_570) = &input.user_name {
scope_569.string(var_570);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_reset_service_specific_credential(
input: &crate::input::ResetServiceSpecificCredentialInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ResetServiceSpecificCredential",
"2010-05-08",
);
#[allow(unused_mut)]
let mut scope_571 = writer.prefix("UserName");
if let Some(var_572) = &input.user_name {
scope_571.string(var_572);
}
#[allow(unused_mut)]
let mut scope_573 = writer.prefix("ServiceSpecificCredentialId");
if let Some(var_574) = &input.service_specific_credential_id {
scope_573.string(var_574);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_resync_mfa_device(
input: &crate::input::ResyncMfaDeviceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ResyncMFADevice", "2010-05-08");
#[allow(unused_mut)]
let mut scope_575 = writer.prefix("UserName");
if let Some(var_576) = &input.user_name {
scope_575.string(var_576);
}
#[allow(unused_mut)]
let mut scope_577 = writer.prefix("SerialNumber");
if let Some(var_578) = &input.serial_number {
scope_577.string(var_578);
}
#[allow(unused_mut)]
let mut scope_579 = writer.prefix("AuthenticationCode1");
if let Some(var_580) = &input.authentication_code1 {
scope_579.string(var_580);
}
#[allow(unused_mut)]
let mut scope_581 = writer.prefix("AuthenticationCode2");
if let Some(var_582) = &input.authentication_code2 {
scope_581.string(var_582);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_set_default_policy_version(
input: &crate::input::SetDefaultPolicyVersionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "SetDefaultPolicyVersion", "2010-05-08");
#[allow(unused_mut)]
let mut scope_583 = writer.prefix("PolicyArn");
if let Some(var_584) = &input.policy_arn {
scope_583.string(var_584);
}
#[allow(unused_mut)]
let mut scope_585 = writer.prefix("VersionId");
if let Some(var_586) = &input.version_id {
scope_585.string(var_586);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_set_security_token_service_preferences(
input: &crate::input::SetSecurityTokenServicePreferencesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"SetSecurityTokenServicePreferences",
"2010-05-08",
);
#[allow(unused_mut)]
let mut scope_587 = writer.prefix("GlobalEndpointTokenVersion");
if let Some(var_588) = &input.global_endpoint_token_version {
scope_587.string(var_588.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_simulate_custom_policy(
input: &crate::input::SimulateCustomPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "SimulateCustomPolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_589 = writer.prefix("PolicyInputList");
if let Some(var_590) = &input.policy_input_list {
let mut list_592 = scope_589.start_list(false, None);
for item_591 in var_590 {
#[allow(unused_mut)]
let mut entry_593 = list_592.entry();
entry_593.string(item_591);
}
list_592.finish();
}
#[allow(unused_mut)]
let mut scope_594 = writer.prefix("PermissionsBoundaryPolicyInputList");
if let Some(var_595) = &input.permissions_boundary_policy_input_list {
let mut list_597 = scope_594.start_list(false, None);
for item_596 in var_595 {
#[allow(unused_mut)]
let mut entry_598 = list_597.entry();
entry_598.string(item_596);
}
list_597.finish();
}
#[allow(unused_mut)]
let mut scope_599 = writer.prefix("ActionNames");
if let Some(var_600) = &input.action_names {
let mut list_602 = scope_599.start_list(false, None);
for item_601 in var_600 {
#[allow(unused_mut)]
let mut entry_603 = list_602.entry();
entry_603.string(item_601);
}
list_602.finish();
}
#[allow(unused_mut)]
let mut scope_604 = writer.prefix("ResourceArns");
if let Some(var_605) = &input.resource_arns {
let mut list_607 = scope_604.start_list(false, None);
for item_606 in var_605 {
#[allow(unused_mut)]
let mut entry_608 = list_607.entry();
entry_608.string(item_606);
}
list_607.finish();
}
#[allow(unused_mut)]
let mut scope_609 = writer.prefix("ResourcePolicy");
if let Some(var_610) = &input.resource_policy {
scope_609.string(var_610);
}
#[allow(unused_mut)]
let mut scope_611 = writer.prefix("ResourceOwner");
if let Some(var_612) = &input.resource_owner {
scope_611.string(var_612);
}
#[allow(unused_mut)]
let mut scope_613 = writer.prefix("CallerArn");
if let Some(var_614) = &input.caller_arn {
scope_613.string(var_614);
}
#[allow(unused_mut)]
let mut scope_615 = writer.prefix("ContextEntries");
if let Some(var_616) = &input.context_entries {
let mut list_618 = scope_615.start_list(false, None);
for item_617 in var_616 {
#[allow(unused_mut)]
let mut entry_619 = list_618.entry();
crate::query_ser::serialize_structure_crate_model_context_entry(entry_619, item_617)?;
}
list_618.finish();
}
#[allow(unused_mut)]
let mut scope_620 = writer.prefix("ResourceHandlingOption");
if let Some(var_621) = &input.resource_handling_option {
scope_620.string(var_621);
}
#[allow(unused_mut)]
let mut scope_622 = writer.prefix("MaxItems");
if let Some(var_623) = &input.max_items {
scope_622.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_623).into()),
);
}
#[allow(unused_mut)]
let mut scope_624 = writer.prefix("Marker");
if let Some(var_625) = &input.marker {
scope_624.string(var_625);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_simulate_principal_policy(
input: &crate::input::SimulatePrincipalPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "SimulatePrincipalPolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_626 = writer.prefix("PolicySourceArn");
if let Some(var_627) = &input.policy_source_arn {
scope_626.string(var_627);
}
#[allow(unused_mut)]
let mut scope_628 = writer.prefix("PolicyInputList");
if let Some(var_629) = &input.policy_input_list {
let mut list_631 = scope_628.start_list(false, None);
for item_630 in var_629 {
#[allow(unused_mut)]
let mut entry_632 = list_631.entry();
entry_632.string(item_630);
}
list_631.finish();
}
#[allow(unused_mut)]
let mut scope_633 = writer.prefix("PermissionsBoundaryPolicyInputList");
if let Some(var_634) = &input.permissions_boundary_policy_input_list {
let mut list_636 = scope_633.start_list(false, None);
for item_635 in var_634 {
#[allow(unused_mut)]
let mut entry_637 = list_636.entry();
entry_637.string(item_635);
}
list_636.finish();
}
#[allow(unused_mut)]
let mut scope_638 = writer.prefix("ActionNames");
if let Some(var_639) = &input.action_names {
let mut list_641 = scope_638.start_list(false, None);
for item_640 in var_639 {
#[allow(unused_mut)]
let mut entry_642 = list_641.entry();
entry_642.string(item_640);
}
list_641.finish();
}
#[allow(unused_mut)]
let mut scope_643 = writer.prefix("ResourceArns");
if let Some(var_644) = &input.resource_arns {
let mut list_646 = scope_643.start_list(false, None);
for item_645 in var_644 {
#[allow(unused_mut)]
let mut entry_647 = list_646.entry();
entry_647.string(item_645);
}
list_646.finish();
}
#[allow(unused_mut)]
let mut scope_648 = writer.prefix("ResourcePolicy");
if let Some(var_649) = &input.resource_policy {
scope_648.string(var_649);
}
#[allow(unused_mut)]
let mut scope_650 = writer.prefix("ResourceOwner");
if let Some(var_651) = &input.resource_owner {
scope_650.string(var_651);
}
#[allow(unused_mut)]
let mut scope_652 = writer.prefix("CallerArn");
if let Some(var_653) = &input.caller_arn {
scope_652.string(var_653);
}
#[allow(unused_mut)]
let mut scope_654 = writer.prefix("ContextEntries");
if let Some(var_655) = &input.context_entries {
let mut list_657 = scope_654.start_list(false, None);
for item_656 in var_655 {
#[allow(unused_mut)]
let mut entry_658 = list_657.entry();
crate::query_ser::serialize_structure_crate_model_context_entry(entry_658, item_656)?;
}
list_657.finish();
}
#[allow(unused_mut)]
let mut scope_659 = writer.prefix("ResourceHandlingOption");
if let Some(var_660) = &input.resource_handling_option {
scope_659.string(var_660);
}
#[allow(unused_mut)]
let mut scope_661 = writer.prefix("MaxItems");
if let Some(var_662) = &input.max_items {
scope_661.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_662).into()),
);
}
#[allow(unused_mut)]
let mut scope_663 = writer.prefix("Marker");
if let Some(var_664) = &input.marker {
scope_663.string(var_664);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_tag_instance_profile(
input: &crate::input::TagInstanceProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "TagInstanceProfile", "2010-05-08");
#[allow(unused_mut)]
let mut scope_665 = writer.prefix("InstanceProfileName");
if let Some(var_666) = &input.instance_profile_name {
scope_665.string(var_666);
}
#[allow(unused_mut)]
let mut scope_667 = writer.prefix("Tags");
if let Some(var_668) = &input.tags {
let mut list_670 = scope_667.start_list(false, None);
for item_669 in var_668 {
#[allow(unused_mut)]
let mut entry_671 = list_670.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_671, item_669)?;
}
list_670.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_tag_mfa_device(
input: &crate::input::TagMfaDeviceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "TagMFADevice", "2010-05-08");
#[allow(unused_mut)]
let mut scope_672 = writer.prefix("SerialNumber");
if let Some(var_673) = &input.serial_number {
scope_672.string(var_673);
}
#[allow(unused_mut)]
let mut scope_674 = writer.prefix("Tags");
if let Some(var_675) = &input.tags {
let mut list_677 = scope_674.start_list(false, None);
for item_676 in var_675 {
#[allow(unused_mut)]
let mut entry_678 = list_677.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_678, item_676)?;
}
list_677.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_tag_open_id_connect_provider(
input: &crate::input::TagOpenIdConnectProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "TagOpenIDConnectProvider", "2010-05-08");
#[allow(unused_mut)]
let mut scope_679 = writer.prefix("OpenIDConnectProviderArn");
if let Some(var_680) = &input.open_id_connect_provider_arn {
scope_679.string(var_680);
}
#[allow(unused_mut)]
let mut scope_681 = writer.prefix("Tags");
if let Some(var_682) = &input.tags {
let mut list_684 = scope_681.start_list(false, None);
for item_683 in var_682 {
#[allow(unused_mut)]
let mut entry_685 = list_684.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_685, item_683)?;
}
list_684.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_tag_policy(
input: &crate::input::TagPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "TagPolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_686 = writer.prefix("PolicyArn");
if let Some(var_687) = &input.policy_arn {
scope_686.string(var_687);
}
#[allow(unused_mut)]
let mut scope_688 = writer.prefix("Tags");
if let Some(var_689) = &input.tags {
let mut list_691 = scope_688.start_list(false, None);
for item_690 in var_689 {
#[allow(unused_mut)]
let mut entry_692 = list_691.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_692, item_690)?;
}
list_691.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_tag_role(
input: &crate::input::TagRoleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "TagRole", "2010-05-08");
#[allow(unused_mut)]
let mut scope_693 = writer.prefix("RoleName");
if let Some(var_694) = &input.role_name {
scope_693.string(var_694);
}
#[allow(unused_mut)]
let mut scope_695 = writer.prefix("Tags");
if let Some(var_696) = &input.tags {
let mut list_698 = scope_695.start_list(false, None);
for item_697 in var_696 {
#[allow(unused_mut)]
let mut entry_699 = list_698.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_699, item_697)?;
}
list_698.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_tag_saml_provider(
input: &crate::input::TagSamlProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "TagSAMLProvider", "2010-05-08");
#[allow(unused_mut)]
let mut scope_700 = writer.prefix("SAMLProviderArn");
if let Some(var_701) = &input.saml_provider_arn {
scope_700.string(var_701);
}
#[allow(unused_mut)]
let mut scope_702 = writer.prefix("Tags");
if let Some(var_703) = &input.tags {
let mut list_705 = scope_702.start_list(false, None);
for item_704 in var_703 {
#[allow(unused_mut)]
let mut entry_706 = list_705.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_706, item_704)?;
}
list_705.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_tag_server_certificate(
input: &crate::input::TagServerCertificateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "TagServerCertificate", "2010-05-08");
#[allow(unused_mut)]
let mut scope_707 = writer.prefix("ServerCertificateName");
if let Some(var_708) = &input.server_certificate_name {
scope_707.string(var_708);
}
#[allow(unused_mut)]
let mut scope_709 = writer.prefix("Tags");
if let Some(var_710) = &input.tags {
let mut list_712 = scope_709.start_list(false, None);
for item_711 in var_710 {
#[allow(unused_mut)]
let mut entry_713 = list_712.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_713, item_711)?;
}
list_712.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_tag_user(
input: &crate::input::TagUserInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "TagUser", "2010-05-08");
#[allow(unused_mut)]
let mut scope_714 = writer.prefix("UserName");
if let Some(var_715) = &input.user_name {
scope_714.string(var_715);
}
#[allow(unused_mut)]
let mut scope_716 = writer.prefix("Tags");
if let Some(var_717) = &input.tags {
let mut list_719 = scope_716.start_list(false, None);
for item_718 in var_717 {
#[allow(unused_mut)]
let mut entry_720 = list_719.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_720, item_718)?;
}
list_719.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_untag_instance_profile(
input: &crate::input::UntagInstanceProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "UntagInstanceProfile", "2010-05-08");
#[allow(unused_mut)]
let mut scope_721 = writer.prefix("InstanceProfileName");
if let Some(var_722) = &input.instance_profile_name {
scope_721.string(var_722);
}
#[allow(unused_mut)]
let mut scope_723 = writer.prefix("TagKeys");
if let Some(var_724) = &input.tag_keys {
let mut list_726 = scope_723.start_list(false, None);
for item_725 in var_724 {
#[allow(unused_mut)]
let mut entry_727 = list_726.entry();
entry_727.string(item_725);
}
list_726.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_untag_mfa_device(
input: &crate::input::UntagMfaDeviceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "UntagMFADevice", "2010-05-08");
#[allow(unused_mut)]
let mut scope_728 = writer.prefix("SerialNumber");
if let Some(var_729) = &input.serial_number {
scope_728.string(var_729);
}
#[allow(unused_mut)]
let mut scope_730 = writer.prefix("TagKeys");
if let Some(var_731) = &input.tag_keys {
let mut list_733 = scope_730.start_list(false, None);
for item_732 in var_731 {
#[allow(unused_mut)]
let mut entry_734 = list_733.entry();
entry_734.string(item_732);
}
list_733.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_untag_open_id_connect_provider(
input: &crate::input::UntagOpenIdConnectProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "UntagOpenIDConnectProvider", "2010-05-08");
#[allow(unused_mut)]
let mut scope_735 = writer.prefix("OpenIDConnectProviderArn");
if let Some(var_736) = &input.open_id_connect_provider_arn {
scope_735.string(var_736);
}
#[allow(unused_mut)]
let mut scope_737 = writer.prefix("TagKeys");
if let Some(var_738) = &input.tag_keys {
let mut list_740 = scope_737.start_list(false, None);
for item_739 in var_738 {
#[allow(unused_mut)]
let mut entry_741 = list_740.entry();
entry_741.string(item_739);
}
list_740.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_untag_policy(
input: &crate::input::UntagPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "UntagPolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_742 = writer.prefix("PolicyArn");
if let Some(var_743) = &input.policy_arn {
scope_742.string(var_743);
}
#[allow(unused_mut)]
let mut scope_744 = writer.prefix("TagKeys");
if let Some(var_745) = &input.tag_keys {
let mut list_747 = scope_744.start_list(false, None);
for item_746 in var_745 {
#[allow(unused_mut)]
let mut entry_748 = list_747.entry();
entry_748.string(item_746);
}
list_747.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_untag_role(
input: &crate::input::UntagRoleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "UntagRole", "2010-05-08");
#[allow(unused_mut)]
let mut scope_749 = writer.prefix("RoleName");
if let Some(var_750) = &input.role_name {
scope_749.string(var_750);
}
#[allow(unused_mut)]
let mut scope_751 = writer.prefix("TagKeys");
if let Some(var_752) = &input.tag_keys {
let mut list_754 = scope_751.start_list(false, None);
for item_753 in var_752 {
#[allow(unused_mut)]
let mut entry_755 = list_754.entry();
entry_755.string(item_753);
}
list_754.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_untag_saml_provider(
input: &crate::input::UntagSamlProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "UntagSAMLProvider", "2010-05-08");
#[allow(unused_mut)]
let mut scope_756 = writer.prefix("SAMLProviderArn");
if let Some(var_757) = &input.saml_provider_arn {
scope_756.string(var_757);
}
#[allow(unused_mut)]
let mut scope_758 = writer.prefix("TagKeys");
if let Some(var_759) = &input.tag_keys {
let mut list_761 = scope_758.start_list(false, None);
for item_760 in var_759 {
#[allow(unused_mut)]
let mut entry_762 = list_761.entry();
entry_762.string(item_760);
}
list_761.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_untag_server_certificate(
input: &crate::input::UntagServerCertificateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "UntagServerCertificate", "2010-05-08");
#[allow(unused_mut)]
let mut scope_763 = writer.prefix("ServerCertificateName");
if let Some(var_764) = &input.server_certificate_name {
scope_763.string(var_764);
}
#[allow(unused_mut)]
let mut scope_765 = writer.prefix("TagKeys");
if let Some(var_766) = &input.tag_keys {
let mut list_768 = scope_765.start_list(false, None);
for item_767 in var_766 {
#[allow(unused_mut)]
let mut entry_769 = list_768.entry();
entry_769.string(item_767);
}
list_768.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_untag_user(
input: &crate::input::UntagUserInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "UntagUser", "2010-05-08");
#[allow(unused_mut)]
let mut scope_770 = writer.prefix("UserName");
if let Some(var_771) = &input.user_name {
scope_770.string(var_771);
}
#[allow(unused_mut)]
let mut scope_772 = writer.prefix("TagKeys");
if let Some(var_773) = &input.tag_keys {
let mut list_775 = scope_772.start_list(false, None);
for item_774 in var_773 {
#[allow(unused_mut)]
let mut entry_776 = list_775.entry();
entry_776.string(item_774);
}
list_775.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_access_key(
input: &crate::input::UpdateAccessKeyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "UpdateAccessKey", "2010-05-08");
#[allow(unused_mut)]
let mut scope_777 = writer.prefix("UserName");
if let Some(var_778) = &input.user_name {
scope_777.string(var_778);
}
#[allow(unused_mut)]
let mut scope_779 = writer.prefix("AccessKeyId");
if let Some(var_780) = &input.access_key_id {
scope_779.string(var_780);
}
#[allow(unused_mut)]
let mut scope_781 = writer.prefix("Status");
if let Some(var_782) = &input.status {
scope_781.string(var_782.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_account_password_policy(
input: &crate::input::UpdateAccountPasswordPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "UpdateAccountPasswordPolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_783 = writer.prefix("MinimumPasswordLength");
if let Some(var_784) = &input.minimum_password_length {
scope_783.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_784).into()),
);
}
#[allow(unused_mut)]
let mut scope_785 = writer.prefix("RequireSymbols");
if input.require_symbols {
scope_785.boolean(input.require_symbols);
}
#[allow(unused_mut)]
let mut scope_786 = writer.prefix("RequireNumbers");
if input.require_numbers {
scope_786.boolean(input.require_numbers);
}
#[allow(unused_mut)]
let mut scope_787 = writer.prefix("RequireUppercaseCharacters");
if input.require_uppercase_characters {
scope_787.boolean(input.require_uppercase_characters);
}
#[allow(unused_mut)]
let mut scope_788 = writer.prefix("RequireLowercaseCharacters");
if input.require_lowercase_characters {
scope_788.boolean(input.require_lowercase_characters);
}
#[allow(unused_mut)]
let mut scope_789 = writer.prefix("AllowUsersToChangePassword");
if input.allow_users_to_change_password {
scope_789.boolean(input.allow_users_to_change_password);
}
#[allow(unused_mut)]
let mut scope_790 = writer.prefix("MaxPasswordAge");
if let Some(var_791) = &input.max_password_age {
scope_790.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_791).into()),
);
}
#[allow(unused_mut)]
let mut scope_792 = writer.prefix("PasswordReusePrevention");
if let Some(var_793) = &input.password_reuse_prevention {
scope_792.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_793).into()),
);
}
#[allow(unused_mut)]
let mut scope_794 = writer.prefix("HardExpiry");
if let Some(var_795) = &input.hard_expiry {
scope_794.boolean(*var_795);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_assume_role_policy(
input: &crate::input::UpdateAssumeRolePolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "UpdateAssumeRolePolicy", "2010-05-08");
#[allow(unused_mut)]
let mut scope_796 = writer.prefix("RoleName");
if let Some(var_797) = &input.role_name {
scope_796.string(var_797);
}
#[allow(unused_mut)]
let mut scope_798 = writer.prefix("PolicyDocument");
if let Some(var_799) = &input.policy_document {
scope_798.string(var_799);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_group(
input: &crate::input::UpdateGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "UpdateGroup", "2010-05-08");
#[allow(unused_mut)]
let mut scope_800 = writer.prefix("GroupName");
if let Some(var_801) = &input.group_name {
scope_800.string(var_801);
}
#[allow(unused_mut)]
let mut scope_802 = writer.prefix("NewPath");
if let Some(var_803) = &input.new_path {
scope_802.string(var_803);
}
#[allow(unused_mut)]
let mut scope_804 = writer.prefix("NewGroupName");
if let Some(var_805) = &input.new_group_name {
scope_804.string(var_805);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_login_profile(
input: &crate::input::UpdateLoginProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "UpdateLoginProfile", "2010-05-08");
#[allow(unused_mut)]
let mut scope_806 = writer.prefix("UserName");
if let Some(var_807) = &input.user_name {
scope_806.string(var_807);
}
#[allow(unused_mut)]
let mut scope_808 = writer.prefix("Password");
if let Some(var_809) = &input.password {
scope_808.string(var_809);
}
#[allow(unused_mut)]
let mut scope_810 = writer.prefix("PasswordResetRequired");
if let Some(var_811) = &input.password_reset_required {
scope_810.boolean(*var_811);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_open_id_connect_provider_thumbprint(
input: &crate::input::UpdateOpenIdConnectProviderThumbprintInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"UpdateOpenIDConnectProviderThumbprint",
"2010-05-08",
);
#[allow(unused_mut)]
let mut scope_812 = writer.prefix("OpenIDConnectProviderArn");
if let Some(var_813) = &input.open_id_connect_provider_arn {
scope_812.string(var_813);
}
#[allow(unused_mut)]
let mut scope_814 = writer.prefix("ThumbprintList");
if let Some(var_815) = &input.thumbprint_list {
let mut list_817 = scope_814.start_list(false, None);
for item_816 in var_815 {
#[allow(unused_mut)]
let mut entry_818 = list_817.entry();
entry_818.string(item_816);
}
list_817.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_role(
input: &crate::input::UpdateRoleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "UpdateRole", "2010-05-08");
#[allow(unused_mut)]
let mut scope_819 = writer.prefix("RoleName");
if let Some(var_820) = &input.role_name {
scope_819.string(var_820);
}
#[allow(unused_mut)]
let mut scope_821 = writer.prefix("Description");
if let Some(var_822) = &input.description {
scope_821.string(var_822);
}
#[allow(unused_mut)]
let mut scope_823 = writer.prefix("MaxSessionDuration");
if let Some(var_824) = &input.max_session_duration {
scope_823.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_824).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_role_description(
input: &crate::input::UpdateRoleDescriptionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "UpdateRoleDescription", "2010-05-08");
#[allow(unused_mut)]
let mut scope_825 = writer.prefix("RoleName");
if let Some(var_826) = &input.role_name {
scope_825.string(var_826);
}
#[allow(unused_mut)]
let mut scope_827 = writer.prefix("Description");
if let Some(var_828) = &input.description {
scope_827.string(var_828);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_saml_provider(
input: &crate::input::UpdateSamlProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "UpdateSAMLProvider", "2010-05-08");
#[allow(unused_mut)]
let mut scope_829 = writer.prefix("SAMLMetadataDocument");
if let Some(var_830) = &input.saml_metadata_document {
scope_829.string(var_830);
}
#[allow(unused_mut)]
let mut scope_831 = writer.prefix("SAMLProviderArn");
if let Some(var_832) = &input.saml_provider_arn {
scope_831.string(var_832);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_server_certificate(
input: &crate::input::UpdateServerCertificateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "UpdateServerCertificate", "2010-05-08");
#[allow(unused_mut)]
let mut scope_833 = writer.prefix("ServerCertificateName");
if let Some(var_834) = &input.server_certificate_name {
scope_833.string(var_834);
}
#[allow(unused_mut)]
let mut scope_835 = writer.prefix("NewPath");
if let Some(var_836) = &input.new_path {
scope_835.string(var_836);
}
#[allow(unused_mut)]
let mut scope_837 = writer.prefix("NewServerCertificateName");
if let Some(var_838) = &input.new_server_certificate_name {
scope_837.string(var_838);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_service_specific_credential(
input: &crate::input::UpdateServiceSpecificCredentialInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"UpdateServiceSpecificCredential",
"2010-05-08",
);
#[allow(unused_mut)]
let mut scope_839 = writer.prefix("UserName");
if let Some(var_840) = &input.user_name {
scope_839.string(var_840);
}
#[allow(unused_mut)]
let mut scope_841 = writer.prefix("ServiceSpecificCredentialId");
if let Some(var_842) = &input.service_specific_credential_id {
scope_841.string(var_842);
}
#[allow(unused_mut)]
let mut scope_843 = writer.prefix("Status");
if let Some(var_844) = &input.status {
scope_843.string(var_844.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_signing_certificate(
input: &crate::input::UpdateSigningCertificateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "UpdateSigningCertificate", "2010-05-08");
#[allow(unused_mut)]
let mut scope_845 = writer.prefix("UserName");
if let Some(var_846) = &input.user_name {
scope_845.string(var_846);
}
#[allow(unused_mut)]
let mut scope_847 = writer.prefix("CertificateId");
if let Some(var_848) = &input.certificate_id {
scope_847.string(var_848);
}
#[allow(unused_mut)]
let mut scope_849 = writer.prefix("Status");
if let Some(var_850) = &input.status {
scope_849.string(var_850.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_ssh_public_key(
input: &crate::input::UpdateSshPublicKeyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "UpdateSSHPublicKey", "2010-05-08");
#[allow(unused_mut)]
let mut scope_851 = writer.prefix("UserName");
if let Some(var_852) = &input.user_name {
scope_851.string(var_852);
}
#[allow(unused_mut)]
let mut scope_853 = writer.prefix("SSHPublicKeyId");
if let Some(var_854) = &input.ssh_public_key_id {
scope_853.string(var_854);
}
#[allow(unused_mut)]
let mut scope_855 = writer.prefix("Status");
if let Some(var_856) = &input.status {
scope_855.string(var_856.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_user(
input: &crate::input::UpdateUserInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "UpdateUser", "2010-05-08");
#[allow(unused_mut)]
let mut scope_857 = writer.prefix("UserName");
if let Some(var_858) = &input.user_name {
scope_857.string(var_858);
}
#[allow(unused_mut)]
let mut scope_859 = writer.prefix("NewPath");
if let Some(var_860) = &input.new_path {
scope_859.string(var_860);
}
#[allow(unused_mut)]
let mut scope_861 = writer.prefix("NewUserName");
if let Some(var_862) = &input.new_user_name {
scope_861.string(var_862);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_upload_server_certificate(
input: &crate::input::UploadServerCertificateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "UploadServerCertificate", "2010-05-08");
#[allow(unused_mut)]
let mut scope_863 = writer.prefix("Path");
if let Some(var_864) = &input.path {
scope_863.string(var_864);
}
#[allow(unused_mut)]
let mut scope_865 = writer.prefix("ServerCertificateName");
if let Some(var_866) = &input.server_certificate_name {
scope_865.string(var_866);
}
#[allow(unused_mut)]
let mut scope_867 = writer.prefix("CertificateBody");
if let Some(var_868) = &input.certificate_body {
scope_867.string(var_868);
}
#[allow(unused_mut)]
let mut scope_869 = writer.prefix("PrivateKey");
if let Some(var_870) = &input.private_key {
scope_869.string(var_870);
}
#[allow(unused_mut)]
let mut scope_871 = writer.prefix("CertificateChain");
if let Some(var_872) = &input.certificate_chain {
scope_871.string(var_872);
}
#[allow(unused_mut)]
let mut scope_873 = writer.prefix("Tags");
if let Some(var_874) = &input.tags {
let mut list_876 = scope_873.start_list(false, None);
for item_875 in var_874 {
#[allow(unused_mut)]
let mut entry_877 = list_876.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_877, item_875)?;
}
list_876.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_upload_signing_certificate(
input: &crate::input::UploadSigningCertificateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "UploadSigningCertificate", "2010-05-08");
#[allow(unused_mut)]
let mut scope_878 = writer.prefix("UserName");
if let Some(var_879) = &input.user_name {
scope_878.string(var_879);
}
#[allow(unused_mut)]
let mut scope_880 = writer.prefix("CertificateBody");
if let Some(var_881) = &input.certificate_body {
scope_880.string(var_881);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_upload_ssh_public_key(
input: &crate::input::UploadSshPublicKeyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "UploadSSHPublicKey", "2010-05-08");
#[allow(unused_mut)]
let mut scope_882 = writer.prefix("UserName");
if let Some(var_883) = &input.user_name {
scope_882.string(var_883);
}
#[allow(unused_mut)]
let mut scope_884 = writer.prefix("SSHPublicKeyBody");
if let Some(var_885) = &input.ssh_public_key_body {
scope_884.string(var_885);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}