pub fn serialize_structure_crate_input_accept_handshake_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AcceptHandshakeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.handshake_id {
object.key("HandshakeId").string(var_1.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_attach_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AttachPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2) = &input.policy_id {
object.key("PolicyId").string(var_2.as_str());
}
if let Some(var_3) = &input.target_id {
object.key("TargetId").string(var_3.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_cancel_handshake_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CancelHandshakeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_4) = &input.handshake_id {
object.key("HandshakeId").string(var_4.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_close_account_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CloseAccountInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_5) = &input.account_id {
object.key("AccountId").string(var_5.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_account_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAccountInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_6) = &input.email {
object.key("Email").string(var_6.as_str());
}
if let Some(var_7) = &input.account_name {
object.key("AccountName").string(var_7.as_str());
}
if let Some(var_8) = &input.role_name {
object.key("RoleName").string(var_8.as_str());
}
if let Some(var_9) = &input.iam_user_access_to_billing {
object.key("IamUserAccessToBilling").string(var_9.as_str());
}
if let Some(var_10) = &input.tags {
let mut array_11 = object.key("Tags").start_array();
for item_12 in var_10 {
{
#[allow(unused_mut)]
let mut object_13 = array_11.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_13, item_12)?;
object_13.finish();
}
}
array_11.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_gov_cloud_account_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateGovCloudAccountInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_14) = &input.email {
object.key("Email").string(var_14.as_str());
}
if let Some(var_15) = &input.account_name {
object.key("AccountName").string(var_15.as_str());
}
if let Some(var_16) = &input.role_name {
object.key("RoleName").string(var_16.as_str());
}
if let Some(var_17) = &input.iam_user_access_to_billing {
object.key("IamUserAccessToBilling").string(var_17.as_str());
}
if let Some(var_18) = &input.tags {
let mut array_19 = object.key("Tags").start_array();
for item_20 in var_18 {
{
#[allow(unused_mut)]
let mut object_21 = array_19.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_21, item_20)?;
object_21.finish();
}
}
array_19.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_organization_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateOrganizationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_22) = &input.feature_set {
object.key("FeatureSet").string(var_22.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_organizational_unit_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateOrganizationalUnitInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_23) = &input.parent_id {
object.key("ParentId").string(var_23.as_str());
}
if let Some(var_24) = &input.name {
object.key("Name").string(var_24.as_str());
}
if let Some(var_25) = &input.tags {
let mut array_26 = object.key("Tags").start_array();
for item_27 in var_25 {
{
#[allow(unused_mut)]
let mut object_28 = array_26.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_28, item_27)?;
object_28.finish();
}
}
array_26.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreatePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_29) = &input.content {
object.key("Content").string(var_29.as_str());
}
if let Some(var_30) = &input.description {
object.key("Description").string(var_30.as_str());
}
if let Some(var_31) = &input.name {
object.key("Name").string(var_31.as_str());
}
if let Some(var_32) = &input.r#type {
object.key("Type").string(var_32.as_str());
}
if let Some(var_33) = &input.tags {
let mut array_34 = object.key("Tags").start_array();
for item_35 in var_33 {
{
#[allow(unused_mut)]
let mut object_36 = array_34.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_36, item_35)?;
object_36.finish();
}
}
array_34.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_decline_handshake_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeclineHandshakeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_37) = &input.handshake_id {
object.key("HandshakeId").string(var_37.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_organizational_unit_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteOrganizationalUnitInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_38) = &input.organizational_unit_id {
object.key("OrganizationalUnitId").string(var_38.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeletePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_39) = &input.policy_id {
object.key("PolicyId").string(var_39.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_deregister_delegated_administrator_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeregisterDelegatedAdministratorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_40) = &input.account_id {
object.key("AccountId").string(var_40.as_str());
}
if let Some(var_41) = &input.service_principal {
object.key("ServicePrincipal").string(var_41.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_account_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAccountInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_42) = &input.account_id {
object.key("AccountId").string(var_42.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_create_account_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeCreateAccountStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_43) = &input.create_account_request_id {
object.key("CreateAccountRequestId").string(var_43.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_effective_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeEffectivePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_44) = &input.policy_type {
object.key("PolicyType").string(var_44.as_str());
}
if let Some(var_45) = &input.target_id {
object.key("TargetId").string(var_45.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_handshake_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeHandshakeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_46) = &input.handshake_id {
object.key("HandshakeId").string(var_46.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_organizational_unit_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeOrganizationalUnitInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_47) = &input.organizational_unit_id {
object.key("OrganizationalUnitId").string(var_47.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_48) = &input.policy_id {
object.key("PolicyId").string(var_48.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_detach_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DetachPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_49) = &input.policy_id {
object.key("PolicyId").string(var_49.as_str());
}
if let Some(var_50) = &input.target_id {
object.key("TargetId").string(var_50.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disable_aws_service_access_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisableAwsServiceAccessInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_51) = &input.service_principal {
object.key("ServicePrincipal").string(var_51.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disable_policy_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisablePolicyTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_52) = &input.root_id {
object.key("RootId").string(var_52.as_str());
}
if let Some(var_53) = &input.policy_type {
object.key("PolicyType").string(var_53.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_enable_aws_service_access_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::EnableAwsServiceAccessInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_54) = &input.service_principal {
object.key("ServicePrincipal").string(var_54.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_enable_policy_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::EnablePolicyTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_55) = &input.root_id {
object.key("RootId").string(var_55.as_str());
}
if let Some(var_56) = &input.policy_type {
object.key("PolicyType").string(var_56.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_invite_account_to_organization_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::InviteAccountToOrganizationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_57) = &input.target {
#[allow(unused_mut)]
let mut object_58 = object.key("Target").start_object();
crate::json_ser::serialize_structure_crate_model_handshake_party(&mut object_58, var_57)?;
object_58.finish();
}
if let Some(var_59) = &input.notes {
object.key("Notes").string(var_59.as_str());
}
if let Some(var_60) = &input.tags {
let mut array_61 = object.key("Tags").start_array();
for item_62 in var_60 {
{
#[allow(unused_mut)]
let mut object_63 = array_61.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_63, item_62)?;
object_63.finish();
}
}
array_61.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_accounts_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAccountsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_64) = &input.next_token {
object.key("NextToken").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()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_accounts_for_parent_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAccountsForParentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_66) = &input.parent_id {
object.key("ParentId").string(var_66.as_str());
}
if let Some(var_67) = &input.next_token {
object.key("NextToken").string(var_67.as_str());
}
if let Some(var_68) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_68).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_aws_service_access_for_organization_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAwsServiceAccessForOrganizationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_69) = &input.next_token {
object.key("NextToken").string(var_69.as_str());
}
if let Some(var_70) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_70).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_children_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListChildrenInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_71) = &input.parent_id {
object.key("ParentId").string(var_71.as_str());
}
if let Some(var_72) = &input.child_type {
object.key("ChildType").string(var_72.as_str());
}
if let Some(var_73) = &input.next_token {
object.key("NextToken").string(var_73.as_str());
}
if let Some(var_74) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_74).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_create_account_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListCreateAccountStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_75) = &input.states {
let mut array_76 = object.key("States").start_array();
for item_77 in var_75 {
{
array_76.value().string(item_77.as_str());
}
}
array_76.finish();
}
if let Some(var_78) = &input.next_token {
object.key("NextToken").string(var_78.as_str());
}
if let Some(var_79) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_79).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_delegated_administrators_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDelegatedAdministratorsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_80) = &input.service_principal {
object.key("ServicePrincipal").string(var_80.as_str());
}
if let Some(var_81) = &input.next_token {
object.key("NextToken").string(var_81.as_str());
}
if let Some(var_82) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_82).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_delegated_services_for_account_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDelegatedServicesForAccountInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_83) = &input.account_id {
object.key("AccountId").string(var_83.as_str());
}
if let Some(var_84) = &input.next_token {
object.key("NextToken").string(var_84.as_str());
}
if let Some(var_85) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_85).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_handshakes_for_account_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListHandshakesForAccountInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_86) = &input.filter {
#[allow(unused_mut)]
let mut object_87 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_handshake_filter(&mut object_87, var_86)?;
object_87.finish();
}
if let Some(var_88) = &input.next_token {
object.key("NextToken").string(var_88.as_str());
}
if let Some(var_89) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_89).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_handshakes_for_organization_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListHandshakesForOrganizationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_90) = &input.filter {
#[allow(unused_mut)]
let mut object_91 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_handshake_filter(&mut object_91, var_90)?;
object_91.finish();
}
if let Some(var_92) = &input.next_token {
object.key("NextToken").string(var_92.as_str());
}
if let Some(var_93) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_93).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_organizational_units_for_parent_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListOrganizationalUnitsForParentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_94) = &input.parent_id {
object.key("ParentId").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_parents_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListParentsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_97) = &input.child_id {
object.key("ChildId").string(var_97.as_str());
}
if let Some(var_98) = &input.next_token {
object.key("NextToken").string(var_98.as_str());
}
if let Some(var_99) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_99).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_policies_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListPoliciesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_100) = &input.filter {
object.key("Filter").string(var_100.as_str());
}
if let Some(var_101) = &input.next_token {
object.key("NextToken").string(var_101.as_str());
}
if let Some(var_102) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_102).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_policies_for_target_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListPoliciesForTargetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_103) = &input.target_id {
object.key("TargetId").string(var_103.as_str());
}
if let Some(var_104) = &input.filter {
object.key("Filter").string(var_104.as_str());
}
if let Some(var_105) = &input.next_token {
object.key("NextToken").string(var_105.as_str());
}
if let Some(var_106) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_106).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_roots_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListRootsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_107) = &input.next_token {
object.key("NextToken").string(var_107.as_str());
}
if let Some(var_108) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_108).into()),
);
}
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_109) = &input.resource_id {
object.key("ResourceId").string(var_109.as_str());
}
if let Some(var_110) = &input.next_token {
object.key("NextToken").string(var_110.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_targets_for_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTargetsForPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_111) = &input.policy_id {
object.key("PolicyId").string(var_111.as_str());
}
if let Some(var_112) = &input.next_token {
object.key("NextToken").string(var_112.as_str());
}
if let Some(var_113) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_113).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_move_account_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::MoveAccountInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_114) = &input.account_id {
object.key("AccountId").string(var_114.as_str());
}
if let Some(var_115) = &input.source_parent_id {
object.key("SourceParentId").string(var_115.as_str());
}
if let Some(var_116) = &input.destination_parent_id {
object.key("DestinationParentId").string(var_116.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_resource_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutResourcePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_117) = &input.content {
object.key("Content").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_register_delegated_administrator_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterDelegatedAdministratorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_122) = &input.account_id {
object.key("AccountId").string(var_122.as_str());
}
if let Some(var_123) = &input.service_principal {
object.key("ServicePrincipal").string(var_123.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_remove_account_from_organization_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RemoveAccountFromOrganizationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_124) = &input.account_id {
object.key("AccountId").string(var_124.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_125) = &input.resource_id {
object.key("ResourceId").string(var_125.as_str());
}
if let Some(var_126) = &input.tags {
let mut array_127 = object.key("Tags").start_array();
for item_128 in var_126 {
{
#[allow(unused_mut)]
let mut object_129 = array_127.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_129, item_128)?;
object_129.finish();
}
}
array_127.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_130) = &input.resource_id {
object.key("ResourceId").string(var_130.as_str());
}
if let Some(var_131) = &input.tag_keys {
let mut array_132 = object.key("TagKeys").start_array();
for item_133 in var_131 {
{
array_132.value().string(item_133.as_str());
}
}
array_132.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_organizational_unit_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateOrganizationalUnitInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_134) = &input.organizational_unit_id {
object.key("OrganizationalUnitId").string(var_134.as_str());
}
if let Some(var_135) = &input.name {
object.key("Name").string(var_135.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdatePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_136) = &input.policy_id {
object.key("PolicyId").string(var_136.as_str());
}
if let Some(var_137) = &input.name {
object.key("Name").string(var_137.as_str());
}
if let Some(var_138) = &input.description {
object.key("Description").string(var_138.as_str());
}
if let Some(var_139) = &input.content {
object.key("Content").string(var_139.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_140) = &input.key {
object.key("Key").string(var_140.as_str());
}
if let Some(var_141) = &input.value {
object.key("Value").string(var_141.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_handshake_party(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HandshakeParty,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_142) = &input.id {
object.key("Id").string(var_142.as_str());
}
if let Some(var_143) = &input.r#type {
object.key("Type").string(var_143.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_handshake_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HandshakeFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_144) = &input.action_type {
object.key("ActionType").string(var_144.as_str());
}
if let Some(var_145) = &input.parent_handshake_id {
object.key("ParentHandshakeId").string(var_145.as_str());
}
Ok(())
}