pub fn serialize_structure_crate_input_attach_customer_managed_policy_reference_to_permission_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AttachCustomerManagedPolicyReferenceToPermissionSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.instance_arn {
object.key("InstanceArn").string(var_1.as_str());
}
if let Some(var_2) = &input.permission_set_arn {
object.key("PermissionSetArn").string(var_2.as_str());
}
if let Some(var_3) = &input.customer_managed_policy_reference {
#[allow(unused_mut)]
let mut object_4 = object.key("CustomerManagedPolicyReference").start_object();
crate::json_ser::serialize_structure_crate_model_customer_managed_policy_reference(
&mut object_4,
var_3,
)?;
object_4.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_attach_managed_policy_to_permission_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AttachManagedPolicyToPermissionSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_5) = &input.instance_arn {
object.key("InstanceArn").string(var_5.as_str());
}
if let Some(var_6) = &input.permission_set_arn {
object.key("PermissionSetArn").string(var_6.as_str());
}
if let Some(var_7) = &input.managed_policy_arn {
object.key("ManagedPolicyArn").string(var_7.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_account_assignment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAccountAssignmentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_8) = &input.instance_arn {
object.key("InstanceArn").string(var_8.as_str());
}
if let Some(var_9) = &input.target_id {
object.key("TargetId").string(var_9.as_str());
}
if let Some(var_10) = &input.target_type {
object.key("TargetType").string(var_10.as_str());
}
if let Some(var_11) = &input.permission_set_arn {
object.key("PermissionSetArn").string(var_11.as_str());
}
if let Some(var_12) = &input.principal_type {
object.key("PrincipalType").string(var_12.as_str());
}
if let Some(var_13) = &input.principal_id {
object.key("PrincipalId").string(var_13.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_instance_access_control_attribute_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateInstanceAccessControlAttributeConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_14) = &input.instance_arn {
object.key("InstanceArn").string(var_14.as_str());
}
if let Some(var_15) = &input.instance_access_control_attribute_configuration {
#[allow(unused_mut)]
let mut object_16 = object
.key("InstanceAccessControlAttributeConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_instance_access_control_attribute_configuration(&mut object_16, var_15)?;
object_16.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_permission_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreatePermissionSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_17) = &input.name {
object.key("Name").string(var_17.as_str());
}
if let Some(var_18) = &input.description {
object.key("Description").string(var_18.as_str());
}
if let Some(var_19) = &input.instance_arn {
object.key("InstanceArn").string(var_19.as_str());
}
if let Some(var_20) = &input.session_duration {
object.key("SessionDuration").string(var_20.as_str());
}
if let Some(var_21) = &input.relay_state {
object.key("RelayState").string(var_21.as_str());
}
if let Some(var_22) = &input.tags {
let mut array_23 = object.key("Tags").start_array();
for item_24 in var_22 {
{
#[allow(unused_mut)]
let mut object_25 = array_23.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_25, item_24)?;
object_25.finish();
}
}
array_23.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_account_assignment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAccountAssignmentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_26) = &input.instance_arn {
object.key("InstanceArn").string(var_26.as_str());
}
if let Some(var_27) = &input.target_id {
object.key("TargetId").string(var_27.as_str());
}
if let Some(var_28) = &input.target_type {
object.key("TargetType").string(var_28.as_str());
}
if let Some(var_29) = &input.permission_set_arn {
object.key("PermissionSetArn").string(var_29.as_str());
}
if let Some(var_30) = &input.principal_type {
object.key("PrincipalType").string(var_30.as_str());
}
if let Some(var_31) = &input.principal_id {
object.key("PrincipalId").string(var_31.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_inline_policy_from_permission_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteInlinePolicyFromPermissionSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_32) = &input.instance_arn {
object.key("InstanceArn").string(var_32.as_str());
}
if let Some(var_33) = &input.permission_set_arn {
object.key("PermissionSetArn").string(var_33.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_instance_access_control_attribute_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteInstanceAccessControlAttributeConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_34) = &input.instance_arn {
object.key("InstanceArn").string(var_34.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_permissions_boundary_from_permission_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeletePermissionsBoundaryFromPermissionSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_35) = &input.instance_arn {
object.key("InstanceArn").string(var_35.as_str());
}
if let Some(var_36) = &input.permission_set_arn {
object.key("PermissionSetArn").string(var_36.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_permission_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeletePermissionSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_37) = &input.instance_arn {
object.key("InstanceArn").string(var_37.as_str());
}
if let Some(var_38) = &input.permission_set_arn {
object.key("PermissionSetArn").string(var_38.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_account_assignment_creation_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAccountAssignmentCreationStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_39) = &input.instance_arn {
object.key("InstanceArn").string(var_39.as_str());
}
if let Some(var_40) = &input.account_assignment_creation_request_id {
object
.key("AccountAssignmentCreationRequestId")
.string(var_40.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_account_assignment_deletion_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAccountAssignmentDeletionStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_41) = &input.instance_arn {
object.key("InstanceArn").string(var_41.as_str());
}
if let Some(var_42) = &input.account_assignment_deletion_request_id {
object
.key("AccountAssignmentDeletionRequestId")
.string(var_42.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_instance_access_control_attribute_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeInstanceAccessControlAttributeConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_43) = &input.instance_arn {
object.key("InstanceArn").string(var_43.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_permission_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribePermissionSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_44) = &input.instance_arn {
object.key("InstanceArn").string(var_44.as_str());
}
if let Some(var_45) = &input.permission_set_arn {
object.key("PermissionSetArn").string(var_45.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_permission_set_provisioning_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribePermissionSetProvisioningStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_46) = &input.instance_arn {
object.key("InstanceArn").string(var_46.as_str());
}
if let Some(var_47) = &input.provision_permission_set_request_id {
object
.key("ProvisionPermissionSetRequestId")
.string(var_47.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_detach_customer_managed_policy_reference_from_permission_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DetachCustomerManagedPolicyReferenceFromPermissionSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_48) = &input.instance_arn {
object.key("InstanceArn").string(var_48.as_str());
}
if let Some(var_49) = &input.permission_set_arn {
object.key("PermissionSetArn").string(var_49.as_str());
}
if let Some(var_50) = &input.customer_managed_policy_reference {
#[allow(unused_mut)]
let mut object_51 = object.key("CustomerManagedPolicyReference").start_object();
crate::json_ser::serialize_structure_crate_model_customer_managed_policy_reference(
&mut object_51,
var_50,
)?;
object_51.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_detach_managed_policy_from_permission_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DetachManagedPolicyFromPermissionSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_52) = &input.instance_arn {
object.key("InstanceArn").string(var_52.as_str());
}
if let Some(var_53) = &input.permission_set_arn {
object.key("PermissionSetArn").string(var_53.as_str());
}
if let Some(var_54) = &input.managed_policy_arn {
object.key("ManagedPolicyArn").string(var_54.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_inline_policy_for_permission_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetInlinePolicyForPermissionSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_55) = &input.instance_arn {
object.key("InstanceArn").string(var_55.as_str());
}
if let Some(var_56) = &input.permission_set_arn {
object.key("PermissionSetArn").string(var_56.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_permissions_boundary_for_permission_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetPermissionsBoundaryForPermissionSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_57) = &input.instance_arn {
object.key("InstanceArn").string(var_57.as_str());
}
if let Some(var_58) = &input.permission_set_arn {
object.key("PermissionSetArn").string(var_58.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_account_assignment_creation_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAccountAssignmentCreationStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_59) = &input.instance_arn {
object.key("InstanceArn").string(var_59.as_str());
}
if let Some(var_60) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_60).into()),
);
}
if let Some(var_61) = &input.next_token {
object.key("NextToken").string(var_61.as_str());
}
if let Some(var_62) = &input.filter {
#[allow(unused_mut)]
let mut object_63 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_operation_status_filter(
&mut object_63,
var_62,
)?;
object_63.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_account_assignment_deletion_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAccountAssignmentDeletionStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_64) = &input.instance_arn {
object.key("InstanceArn").string(var_64.as_str());
}
if let Some(var_65) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_65).into()),
);
}
if let Some(var_66) = &input.next_token {
object.key("NextToken").string(var_66.as_str());
}
if let Some(var_67) = &input.filter {
#[allow(unused_mut)]
let mut object_68 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_operation_status_filter(
&mut object_68,
var_67,
)?;
object_68.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_account_assignments_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAccountAssignmentsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_69) = &input.instance_arn {
object.key("InstanceArn").string(var_69.as_str());
}
if let Some(var_70) = &input.account_id {
object.key("AccountId").string(var_70.as_str());
}
if let Some(var_71) = &input.permission_set_arn {
object.key("PermissionSetArn").string(var_71.as_str());
}
if let Some(var_72) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_72).into()),
);
}
if let Some(var_73) = &input.next_token {
object.key("NextToken").string(var_73.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_accounts_for_provisioned_permission_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAccountsForProvisionedPermissionSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_74) = &input.instance_arn {
object.key("InstanceArn").string(var_74.as_str());
}
if let Some(var_75) = &input.permission_set_arn {
object.key("PermissionSetArn").string(var_75.as_str());
}
if let Some(var_76) = &input.provisioning_status {
object.key("ProvisioningStatus").string(var_76.as_str());
}
if let Some(var_77) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_77).into()),
);
}
if let Some(var_78) = &input.next_token {
object.key("NextToken").string(var_78.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_customer_managed_policy_references_in_permission_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListCustomerManagedPolicyReferencesInPermissionSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_79) = &input.instance_arn {
object.key("InstanceArn").string(var_79.as_str());
}
if let Some(var_80) = &input.permission_set_arn {
object.key("PermissionSetArn").string(var_80.as_str());
}
if let Some(var_81) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_81).into()),
);
}
if let Some(var_82) = &input.next_token {
object.key("NextToken").string(var_82.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_instances_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListInstancesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_83) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_83).into()),
);
}
if let Some(var_84) = &input.next_token {
object.key("NextToken").string(var_84.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_managed_policies_in_permission_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListManagedPoliciesInPermissionSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.instance_arn {
object.key("InstanceArn").string(var_85.as_str());
}
if let Some(var_86) = &input.permission_set_arn {
object.key("PermissionSetArn").string(var_86.as_str());
}
if let Some(var_87) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_87).into()),
);
}
if let Some(var_88) = &input.next_token {
object.key("NextToken").string(var_88.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_permission_set_provisioning_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListPermissionSetProvisioningStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_89) = &input.instance_arn {
object.key("InstanceArn").string(var_89.as_str());
}
if let Some(var_90) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_90).into()),
);
}
if let Some(var_91) = &input.next_token {
object.key("NextToken").string(var_91.as_str());
}
if let Some(var_92) = &input.filter {
#[allow(unused_mut)]
let mut object_93 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_operation_status_filter(
&mut object_93,
var_92,
)?;
object_93.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_permission_sets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListPermissionSetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_94) = &input.instance_arn {
object.key("InstanceArn").string(var_94.as_str());
}
if let Some(var_95) = &input.next_token {
object.key("NextToken").string(var_95.as_str());
}
if let Some(var_96) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_96).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_permission_sets_provisioned_to_account_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListPermissionSetsProvisionedToAccountInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_97) = &input.instance_arn {
object.key("InstanceArn").string(var_97.as_str());
}
if let Some(var_98) = &input.account_id {
object.key("AccountId").string(var_98.as_str());
}
if let Some(var_99) = &input.provisioning_status {
object.key("ProvisioningStatus").string(var_99.as_str());
}
if let Some(var_100) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_100).into()),
);
}
if let Some(var_101) = &input.next_token {
object.key("NextToken").string(var_101.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tags_for_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTagsForResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_102) = &input.instance_arn {
object.key("InstanceArn").string(var_102.as_str());
}
if let Some(var_103) = &input.resource_arn {
object.key("ResourceArn").string(var_103.as_str());
}
if let Some(var_104) = &input.next_token {
object.key("NextToken").string(var_104.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_provision_permission_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ProvisionPermissionSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_105) = &input.instance_arn {
object.key("InstanceArn").string(var_105.as_str());
}
if let Some(var_106) = &input.permission_set_arn {
object.key("PermissionSetArn").string(var_106.as_str());
}
if let Some(var_107) = &input.target_id {
object.key("TargetId").string(var_107.as_str());
}
if let Some(var_108) = &input.target_type {
object.key("TargetType").string(var_108.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_inline_policy_to_permission_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutInlinePolicyToPermissionSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_109) = &input.instance_arn {
object.key("InstanceArn").string(var_109.as_str());
}
if let Some(var_110) = &input.permission_set_arn {
object.key("PermissionSetArn").string(var_110.as_str());
}
if let Some(var_111) = &input.inline_policy {
object.key("InlinePolicy").string(var_111.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_permissions_boundary_to_permission_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutPermissionsBoundaryToPermissionSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_112) = &input.instance_arn {
object.key("InstanceArn").string(var_112.as_str());
}
if let Some(var_113) = &input.permission_set_arn {
object.key("PermissionSetArn").string(var_113.as_str());
}
if let Some(var_114) = &input.permissions_boundary {
#[allow(unused_mut)]
let mut object_115 = object.key("PermissionsBoundary").start_object();
crate::json_ser::serialize_structure_crate_model_permissions_boundary(
&mut object_115,
var_114,
)?;
object_115.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_116) = &input.instance_arn {
object.key("InstanceArn").string(var_116.as_str());
}
if let Some(var_117) = &input.resource_arn {
object.key("ResourceArn").string(var_117.as_str());
}
if let Some(var_118) = &input.tags {
let mut array_119 = object.key("Tags").start_array();
for item_120 in var_118 {
{
#[allow(unused_mut)]
let mut object_121 = array_119.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_121, item_120)?;
object_121.finish();
}
}
array_119.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_untag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UntagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_122) = &input.instance_arn {
object.key("InstanceArn").string(var_122.as_str());
}
if let Some(var_123) = &input.resource_arn {
object.key("ResourceArn").string(var_123.as_str());
}
if let Some(var_124) = &input.tag_keys {
let mut array_125 = object.key("TagKeys").start_array();
for item_126 in var_124 {
{
array_125.value().string(item_126.as_str());
}
}
array_125.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_instance_access_control_attribute_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateInstanceAccessControlAttributeConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_127) = &input.instance_arn {
object.key("InstanceArn").string(var_127.as_str());
}
if let Some(var_128) = &input.instance_access_control_attribute_configuration {
#[allow(unused_mut)]
let mut object_129 = object
.key("InstanceAccessControlAttributeConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_instance_access_control_attribute_configuration(&mut object_129, var_128)?;
object_129.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_permission_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdatePermissionSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_130) = &input.instance_arn {
object.key("InstanceArn").string(var_130.as_str());
}
if let Some(var_131) = &input.permission_set_arn {
object.key("PermissionSetArn").string(var_131.as_str());
}
if let Some(var_132) = &input.description {
object.key("Description").string(var_132.as_str());
}
if let Some(var_133) = &input.session_duration {
object.key("SessionDuration").string(var_133.as_str());
}
if let Some(var_134) = &input.relay_state {
object.key("RelayState").string(var_134.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_customer_managed_policy_reference(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomerManagedPolicyReference,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_135) = &input.name {
object.key("Name").string(var_135.as_str());
}
if let Some(var_136) = &input.path {
object.key("Path").string(var_136.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_instance_access_control_attribute_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InstanceAccessControlAttributeConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_137) = &input.access_control_attributes {
let mut array_138 = object.key("AccessControlAttributes").start_array();
for item_139 in var_137 {
{
#[allow(unused_mut)]
let mut object_140 = array_138.value().start_object();
crate::json_ser::serialize_structure_crate_model_access_control_attribute(
&mut object_140,
item_139,
)?;
object_140.finish();
}
}
array_138.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_141) = &input.key {
object.key("Key").string(var_141.as_str());
}
if let Some(var_142) = &input.value {
object.key("Value").string(var_142.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_operation_status_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OperationStatusFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_143) = &input.status {
object.key("Status").string(var_143.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_permissions_boundary(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PermissionsBoundary,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_144) = &input.customer_managed_policy_reference {
#[allow(unused_mut)]
let mut object_145 = object.key("CustomerManagedPolicyReference").start_object();
crate::json_ser::serialize_structure_crate_model_customer_managed_policy_reference(
&mut object_145,
var_144,
)?;
object_145.finish();
}
if let Some(var_146) = &input.managed_policy_arn {
object.key("ManagedPolicyArn").string(var_146.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_access_control_attribute(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AccessControlAttribute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_147) = &input.key {
object.key("Key").string(var_147.as_str());
}
if let Some(var_148) = &input.value {
#[allow(unused_mut)]
let mut object_149 = object.key("Value").start_object();
crate::json_ser::serialize_structure_crate_model_access_control_attribute_value(
&mut object_149,
var_148,
)?;
object_149.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_access_control_attribute_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AccessControlAttributeValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_150) = &input.source {
let mut array_151 = object.key("Source").start_array();
for item_152 in var_150 {
{
array_151.value().string(item_152.as_str());
}
}
array_151.finish();
}
Ok(())
}