pub fn serialize_structure_crate_input_accept_administrator_invitation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AcceptAdministratorInvitationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.administrator_id {
object.key("AdministratorId").string(var_1.as_str());
}
if let Some(var_2) = &input.invitation_id {
object.key("InvitationId").string(var_2.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_accept_invitation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AcceptInvitationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3) = &input.invitation_id {
object.key("InvitationId").string(var_3.as_str());
}
if let Some(var_4) = &input.master_id {
object.key("MasterId").string(var_4.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_disable_standards_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchDisableStandardsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_5) = &input.standards_subscription_arns {
let mut array_6 = object.key("StandardsSubscriptionArns").start_array();
for item_7 in var_5 {
{
array_6.value().string(item_7.as_str());
}
}
array_6.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_enable_standards_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchEnableStandardsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_8) = &input.standards_subscription_requests {
let mut array_9 = object.key("StandardsSubscriptionRequests").start_array();
for item_10 in var_8 {
{
#[allow(unused_mut)]
let mut object_11 = array_9.value().start_object();
crate::json_ser::serialize_structure_crate_model_standards_subscription_request(
&mut object_11,
item_10,
)?;
object_11.finish();
}
}
array_9.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_import_findings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchImportFindingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_12) = &input.findings {
let mut array_13 = object.key("Findings").start_array();
for item_14 in var_12 {
{
#[allow(unused_mut)]
let mut object_15 = array_13.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_security_finding(
&mut object_15,
item_14,
)?;
object_15.finish();
}
}
array_13.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_update_findings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchUpdateFindingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.confidence != 0 {
object.key("Confidence").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.confidence).into()),
);
}
if input.criticality != 0 {
object.key("Criticality").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.criticality).into()),
);
}
if let Some(var_16) = &input.finding_identifiers {
let mut array_17 = object.key("FindingIdentifiers").start_array();
for item_18 in var_16 {
{
#[allow(unused_mut)]
let mut object_19 = array_17.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_security_finding_identifier(
&mut object_19,
item_18,
)?;
object_19.finish();
}
}
array_17.finish();
}
if let Some(var_20) = &input.note {
#[allow(unused_mut)]
let mut object_21 = object.key("Note").start_object();
crate::json_ser::serialize_structure_crate_model_note_update(&mut object_21, var_20)?;
object_21.finish();
}
if let Some(var_22) = &input.related_findings {
let mut array_23 = object.key("RelatedFindings").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_related_finding(
&mut object_25,
item_24,
)?;
object_25.finish();
}
}
array_23.finish();
}
if let Some(var_26) = &input.severity {
#[allow(unused_mut)]
let mut object_27 = object.key("Severity").start_object();
crate::json_ser::serialize_structure_crate_model_severity_update(&mut object_27, var_26)?;
object_27.finish();
}
if let Some(var_28) = &input.types {
let mut array_29 = object.key("Types").start_array();
for item_30 in var_28 {
{
array_29.value().string(item_30.as_str());
}
}
array_29.finish();
}
if let Some(var_31) = &input.user_defined_fields {
#[allow(unused_mut)]
let mut object_32 = object.key("UserDefinedFields").start_object();
for (key_33, value_34) in var_31 {
{
object_32.key(key_33.as_str()).string(value_34.as_str());
}
}
object_32.finish();
}
if let Some(var_35) = &input.verification_state {
object.key("VerificationState").string(var_35.as_str());
}
if let Some(var_36) = &input.workflow {
#[allow(unused_mut)]
let mut object_37 = object.key("Workflow").start_object();
crate::json_ser::serialize_structure_crate_model_workflow_update(&mut object_37, var_36)?;
object_37.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_action_target_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateActionTargetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_38) = &input.description {
object.key("Description").string(var_38.as_str());
}
if let Some(var_39) = &input.id {
object.key("Id").string(var_39.as_str());
}
if let Some(var_40) = &input.name {
object.key("Name").string(var_40.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_finding_aggregator_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFindingAggregatorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_41) = &input.region_linking_mode {
object.key("RegionLinkingMode").string(var_41.as_str());
}
if let Some(var_42) = &input.regions {
let mut array_43 = object.key("Regions").start_array();
for item_44 in var_42 {
{
array_43.value().string(item_44.as_str());
}
}
array_43.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_insight_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateInsightInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_45) = &input.filters {
#[allow(unused_mut)]
let mut object_46 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_aws_security_finding_filters(
&mut object_46,
var_45,
)?;
object_46.finish();
}
if let Some(var_47) = &input.group_by_attribute {
object.key("GroupByAttribute").string(var_47.as_str());
}
if let Some(var_48) = &input.name {
object.key("Name").string(var_48.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_members_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateMembersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_49) = &input.account_details {
let mut array_50 = object.key("AccountDetails").start_array();
for item_51 in var_49 {
{
#[allow(unused_mut)]
let mut object_52 = array_50.value().start_object();
crate::json_ser::serialize_structure_crate_model_account_details(
&mut object_52,
item_51,
)?;
object_52.finish();
}
}
array_50.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_decline_invitations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeclineInvitationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_53) = &input.account_ids {
let mut array_54 = object.key("AccountIds").start_array();
for item_55 in var_53 {
{
array_54.value().string(item_55.as_str());
}
}
array_54.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_invitations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteInvitationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_56) = &input.account_ids {
let mut array_57 = object.key("AccountIds").start_array();
for item_58 in var_56 {
{
array_57.value().string(item_58.as_str());
}
}
array_57.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_members_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteMembersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_59) = &input.account_ids {
let mut array_60 = object.key("AccountIds").start_array();
for item_61 in var_59 {
{
array_60.value().string(item_61.as_str());
}
}
array_60.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_action_targets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeActionTargetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_62) = &input.action_target_arns {
let mut array_63 = object.key("ActionTargetArns").start_array();
for item_64 in var_62 {
{
array_63.value().string(item_64.as_str());
}
}
array_63.finish();
}
if input.max_results != 0 {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_65) = &input.next_token {
object.key("NextToken").string(var_65.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disable_organization_admin_account_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisableOrganizationAdminAccountInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_66) = &input.admin_account_id {
object.key("AdminAccountId").string(var_66.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_members_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateMembersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_67) = &input.account_ids {
let mut array_68 = object.key("AccountIds").start_array();
for item_69 in var_67 {
{
array_68.value().string(item_69.as_str());
}
}
array_68.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_enable_import_findings_for_product_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::EnableImportFindingsForProductInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_70) = &input.product_arn {
object.key("ProductArn").string(var_70.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_enable_organization_admin_account_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::EnableOrganizationAdminAccountInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_71) = &input.admin_account_id {
object.key("AdminAccountId").string(var_71.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_enable_security_hub_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::EnableSecurityHubInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enable_default_standards {
object
.key("EnableDefaultStandards")
.boolean(input.enable_default_standards);
}
if let Some(var_72) = &input.tags {
#[allow(unused_mut)]
let mut object_73 = object.key("Tags").start_object();
for (key_74, value_75) in var_72 {
{
object_73.key(key_74.as_str()).string(value_75.as_str());
}
}
object_73.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_enabled_standards_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetEnabledStandardsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.max_results != 0 {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_76) = &input.next_token {
object.key("NextToken").string(var_76.as_str());
}
if let Some(var_77) = &input.standards_subscription_arns {
let mut array_78 = object.key("StandardsSubscriptionArns").start_array();
for item_79 in var_77 {
{
array_78.value().string(item_79.as_str());
}
}
array_78.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_findings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetFindingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_80) = &input.filters {
#[allow(unused_mut)]
let mut object_81 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_aws_security_finding_filters(
&mut object_81,
var_80,
)?;
object_81.finish();
}
if input.max_results != 0 {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_82) = &input.next_token {
object.key("NextToken").string(var_82.as_str());
}
if let Some(var_83) = &input.sort_criteria {
let mut array_84 = object.key("SortCriteria").start_array();
for item_85 in var_83 {
{
#[allow(unused_mut)]
let mut object_86 = array_84.value().start_object();
crate::json_ser::serialize_structure_crate_model_sort_criterion(
&mut object_86,
item_85,
)?;
object_86.finish();
}
}
array_84.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_insights_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetInsightsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_87) = &input.insight_arns {
let mut array_88 = object.key("InsightArns").start_array();
for item_89 in var_87 {
{
array_88.value().string(item_89.as_str());
}
}
array_88.finish();
}
if input.max_results != 0 {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_90) = &input.next_token {
object.key("NextToken").string(var_90.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_members_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetMembersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_91) = &input.account_ids {
let mut array_92 = object.key("AccountIds").start_array();
for item_93 in var_91 {
{
array_92.value().string(item_93.as_str());
}
}
array_92.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_invite_members_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::InviteMembersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_94) = &input.account_ids {
let mut array_95 = object.key("AccountIds").start_array();
for item_96 in var_94 {
{
array_95.value().string(item_96.as_str());
}
}
array_95.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_97) = &input.tags {
#[allow(unused_mut)]
let mut object_98 = object.key("Tags").start_object();
for (key_99, value_100) in var_97 {
{
object_98.key(key_99.as_str()).string(value_100.as_str());
}
}
object_98.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_action_target_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateActionTargetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_101) = &input.description {
object.key("Description").string(var_101.as_str());
}
if let Some(var_102) = &input.name {
object.key("Name").string(var_102.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_finding_aggregator_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFindingAggregatorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_103) = &input.finding_aggregator_arn {
object.key("FindingAggregatorArn").string(var_103.as_str());
}
if let Some(var_104) = &input.region_linking_mode {
object.key("RegionLinkingMode").string(var_104.as_str());
}
if let Some(var_105) = &input.regions {
let mut array_106 = object.key("Regions").start_array();
for item_107 in var_105 {
{
array_106.value().string(item_107.as_str());
}
}
array_106.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_findings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFindingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_108) = &input.filters {
#[allow(unused_mut)]
let mut object_109 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_aws_security_finding_filters(
&mut object_109,
var_108,
)?;
object_109.finish();
}
if let Some(var_110) = &input.note {
#[allow(unused_mut)]
let mut object_111 = object.key("Note").start_object();
crate::json_ser::serialize_structure_crate_model_note_update(&mut object_111, var_110)?;
object_111.finish();
}
if let Some(var_112) = &input.record_state {
object.key("RecordState").string(var_112.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_insight_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateInsightInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_113) = &input.filters {
#[allow(unused_mut)]
let mut object_114 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_aws_security_finding_filters(
&mut object_114,
var_113,
)?;
object_114.finish();
}
if let Some(var_115) = &input.group_by_attribute {
object.key("GroupByAttribute").string(var_115.as_str());
}
if let Some(var_116) = &input.name {
object.key("Name").string(var_116.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_organization_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateOrganizationConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("AutoEnable").boolean(input.auto_enable);
}
if let Some(var_117) = &input.auto_enable_standards {
object.key("AutoEnableStandards").string(var_117.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_security_hub_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSecurityHubConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.auto_enable_controls {
object
.key("AutoEnableControls")
.boolean(input.auto_enable_controls);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_standards_control_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateStandardsControlInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_118) = &input.control_status {
object.key("ControlStatus").string(var_118.as_str());
}
if let Some(var_119) = &input.disabled_reason {
object.key("DisabledReason").string(var_119.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_standards_subscription_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StandardsSubscriptionRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_120) = &input.standards_arn {
object.key("StandardsArn").string(var_120.as_str());
}
if let Some(var_121) = &input.standards_input {
#[allow(unused_mut)]
let mut object_122 = object.key("StandardsInput").start_object();
for (key_123, value_124) in var_121 {
{
object_122.key(key_123.as_str()).string(value_124.as_str());
}
}
object_122.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_security_finding(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsSecurityFinding,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_125) = &input.schema_version {
object.key("SchemaVersion").string(var_125.as_str());
}
if let Some(var_126) = &input.id {
object.key("Id").string(var_126.as_str());
}
if let Some(var_127) = &input.product_arn {
object.key("ProductArn").string(var_127.as_str());
}
if let Some(var_128) = &input.product_name {
object.key("ProductName").string(var_128.as_str());
}
if let Some(var_129) = &input.company_name {
object.key("CompanyName").string(var_129.as_str());
}
if let Some(var_130) = &input.region {
object.key("Region").string(var_130.as_str());
}
if let Some(var_131) = &input.generator_id {
object.key("GeneratorId").string(var_131.as_str());
}
if let Some(var_132) = &input.aws_account_id {
object.key("AwsAccountId").string(var_132.as_str());
}
if let Some(var_133) = &input.types {
let mut array_134 = object.key("Types").start_array();
for item_135 in var_133 {
{
array_134.value().string(item_135.as_str());
}
}
array_134.finish();
}
if let Some(var_136) = &input.first_observed_at {
object.key("FirstObservedAt").string(var_136.as_str());
}
if let Some(var_137) = &input.last_observed_at {
object.key("LastObservedAt").string(var_137.as_str());
}
if let Some(var_138) = &input.created_at {
object.key("CreatedAt").string(var_138.as_str());
}
if let Some(var_139) = &input.updated_at {
object.key("UpdatedAt").string(var_139.as_str());
}
if let Some(var_140) = &input.severity {
#[allow(unused_mut)]
let mut object_141 = object.key("Severity").start_object();
crate::json_ser::serialize_structure_crate_model_severity(&mut object_141, var_140)?;
object_141.finish();
}
if input.confidence != 0 {
object.key("Confidence").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.confidence).into()),
);
}
if input.criticality != 0 {
object.key("Criticality").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.criticality).into()),
);
}
if let Some(var_142) = &input.title {
object.key("Title").string(var_142.as_str());
}
if let Some(var_143) = &input.description {
object.key("Description").string(var_143.as_str());
}
if let Some(var_144) = &input.remediation {
#[allow(unused_mut)]
let mut object_145 = object.key("Remediation").start_object();
crate::json_ser::serialize_structure_crate_model_remediation(&mut object_145, var_144)?;
object_145.finish();
}
if let Some(var_146) = &input.source_url {
object.key("SourceUrl").string(var_146.as_str());
}
if let Some(var_147) = &input.product_fields {
#[allow(unused_mut)]
let mut object_148 = object.key("ProductFields").start_object();
for (key_149, value_150) in var_147 {
{
object_148.key(key_149.as_str()).string(value_150.as_str());
}
}
object_148.finish();
}
if let Some(var_151) = &input.user_defined_fields {
#[allow(unused_mut)]
let mut object_152 = object.key("UserDefinedFields").start_object();
for (key_153, value_154) in var_151 {
{
object_152.key(key_153.as_str()).string(value_154.as_str());
}
}
object_152.finish();
}
if let Some(var_155) = &input.malware {
let mut array_156 = object.key("Malware").start_array();
for item_157 in var_155 {
{
#[allow(unused_mut)]
let mut object_158 = array_156.value().start_object();
crate::json_ser::serialize_structure_crate_model_malware(
&mut object_158,
item_157,
)?;
object_158.finish();
}
}
array_156.finish();
}
if let Some(var_159) = &input.network {
#[allow(unused_mut)]
let mut object_160 = object.key("Network").start_object();
crate::json_ser::serialize_structure_crate_model_network(&mut object_160, var_159)?;
object_160.finish();
}
if let Some(var_161) = &input.network_path {
let mut array_162 = object.key("NetworkPath").start_array();
for item_163 in var_161 {
{
#[allow(unused_mut)]
let mut object_164 = array_162.value().start_object();
crate::json_ser::serialize_structure_crate_model_network_path_component(
&mut object_164,
item_163,
)?;
object_164.finish();
}
}
array_162.finish();
}
if let Some(var_165) = &input.process {
#[allow(unused_mut)]
let mut object_166 = object.key("Process").start_object();
crate::json_ser::serialize_structure_crate_model_process_details(&mut object_166, var_165)?;
object_166.finish();
}
if let Some(var_167) = &input.threats {
let mut array_168 = object.key("Threats").start_array();
for item_169 in var_167 {
{
#[allow(unused_mut)]
let mut object_170 = array_168.value().start_object();
crate::json_ser::serialize_structure_crate_model_threat(&mut object_170, item_169)?;
object_170.finish();
}
}
array_168.finish();
}
if let Some(var_171) = &input.threat_intel_indicators {
let mut array_172 = object.key("ThreatIntelIndicators").start_array();
for item_173 in var_171 {
{
#[allow(unused_mut)]
let mut object_174 = array_172.value().start_object();
crate::json_ser::serialize_structure_crate_model_threat_intel_indicator(
&mut object_174,
item_173,
)?;
object_174.finish();
}
}
array_172.finish();
}
if let Some(var_175) = &input.resources {
let mut array_176 = object.key("Resources").start_array();
for item_177 in var_175 {
{
#[allow(unused_mut)]
let mut object_178 = array_176.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource(
&mut object_178,
item_177,
)?;
object_178.finish();
}
}
array_176.finish();
}
if let Some(var_179) = &input.compliance {
#[allow(unused_mut)]
let mut object_180 = object.key("Compliance").start_object();
crate::json_ser::serialize_structure_crate_model_compliance(&mut object_180, var_179)?;
object_180.finish();
}
if let Some(var_181) = &input.verification_state {
object.key("VerificationState").string(var_181.as_str());
}
if let Some(var_182) = &input.workflow_state {
object.key("WorkflowState").string(var_182.as_str());
}
if let Some(var_183) = &input.workflow {
#[allow(unused_mut)]
let mut object_184 = object.key("Workflow").start_object();
crate::json_ser::serialize_structure_crate_model_workflow(&mut object_184, var_183)?;
object_184.finish();
}
if let Some(var_185) = &input.record_state {
object.key("RecordState").string(var_185.as_str());
}
if let Some(var_186) = &input.related_findings {
let mut array_187 = object.key("RelatedFindings").start_array();
for item_188 in var_186 {
{
#[allow(unused_mut)]
let mut object_189 = array_187.value().start_object();
crate::json_ser::serialize_structure_crate_model_related_finding(
&mut object_189,
item_188,
)?;
object_189.finish();
}
}
array_187.finish();
}
if let Some(var_190) = &input.note {
#[allow(unused_mut)]
let mut object_191 = object.key("Note").start_object();
crate::json_ser::serialize_structure_crate_model_note(&mut object_191, var_190)?;
object_191.finish();
}
if let Some(var_192) = &input.vulnerabilities {
let mut array_193 = object.key("Vulnerabilities").start_array();
for item_194 in var_192 {
{
#[allow(unused_mut)]
let mut object_195 = array_193.value().start_object();
crate::json_ser::serialize_structure_crate_model_vulnerability(
&mut object_195,
item_194,
)?;
object_195.finish();
}
}
array_193.finish();
}
if let Some(var_196) = &input.patch_summary {
#[allow(unused_mut)]
let mut object_197 = object.key("PatchSummary").start_object();
crate::json_ser::serialize_structure_crate_model_patch_summary(&mut object_197, var_196)?;
object_197.finish();
}
if let Some(var_198) = &input.action {
#[allow(unused_mut)]
let mut object_199 = object.key("Action").start_object();
crate::json_ser::serialize_structure_crate_model_action(&mut object_199, var_198)?;
object_199.finish();
}
if let Some(var_200) = &input.finding_provider_fields {
#[allow(unused_mut)]
let mut object_201 = object.key("FindingProviderFields").start_object();
crate::json_ser::serialize_structure_crate_model_finding_provider_fields(
&mut object_201,
var_200,
)?;
object_201.finish();
}
if input.sample {
object.key("Sample").boolean(input.sample);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_security_finding_identifier(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsSecurityFindingIdentifier,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_202) = &input.id {
object.key("Id").string(var_202.as_str());
}
if let Some(var_203) = &input.product_arn {
object.key("ProductArn").string(var_203.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_note_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NoteUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_204) = &input.text {
object.key("Text").string(var_204.as_str());
}
if let Some(var_205) = &input.updated_by {
object.key("UpdatedBy").string(var_205.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_related_finding(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RelatedFinding,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_206) = &input.product_arn {
object.key("ProductArn").string(var_206.as_str());
}
if let Some(var_207) = &input.id {
object.key("Id").string(var_207.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_severity_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SeverityUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.normalized != 0 {
object.key("Normalized").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.normalized).into()),
);
}
if input.product != 0.0 {
object.key("Product").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.product).into()),
);
}
if let Some(var_208) = &input.label {
object.key("Label").string(var_208.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_workflow_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WorkflowUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_209) = &input.status {
object.key("Status").string(var_209.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_security_finding_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsSecurityFindingFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_210) = &input.product_arn {
let mut array_211 = object.key("ProductArn").start_array();
for item_212 in var_210 {
{
#[allow(unused_mut)]
let mut object_213 = array_211.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_213,
item_212,
)?;
object_213.finish();
}
}
array_211.finish();
}
if let Some(var_214) = &input.aws_account_id {
let mut array_215 = object.key("AwsAccountId").start_array();
for item_216 in var_214 {
{
#[allow(unused_mut)]
let mut object_217 = array_215.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_217,
item_216,
)?;
object_217.finish();
}
}
array_215.finish();
}
if let Some(var_218) = &input.id {
let mut array_219 = object.key("Id").start_array();
for item_220 in var_218 {
{
#[allow(unused_mut)]
let mut object_221 = array_219.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_221,
item_220,
)?;
object_221.finish();
}
}
array_219.finish();
}
if let Some(var_222) = &input.generator_id {
let mut array_223 = object.key("GeneratorId").start_array();
for item_224 in var_222 {
{
#[allow(unused_mut)]
let mut object_225 = array_223.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_225,
item_224,
)?;
object_225.finish();
}
}
array_223.finish();
}
if let Some(var_226) = &input.region {
let mut array_227 = object.key("Region").start_array();
for item_228 in var_226 {
{
#[allow(unused_mut)]
let mut object_229 = array_227.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_229,
item_228,
)?;
object_229.finish();
}
}
array_227.finish();
}
if let Some(var_230) = &input.r#type {
let mut array_231 = object.key("Type").start_array();
for item_232 in var_230 {
{
#[allow(unused_mut)]
let mut object_233 = array_231.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_233,
item_232,
)?;
object_233.finish();
}
}
array_231.finish();
}
if let Some(var_234) = &input.first_observed_at {
let mut array_235 = object.key("FirstObservedAt").start_array();
for item_236 in var_234 {
{
#[allow(unused_mut)]
let mut object_237 = array_235.value().start_object();
crate::json_ser::serialize_structure_crate_model_date_filter(
&mut object_237,
item_236,
)?;
object_237.finish();
}
}
array_235.finish();
}
if let Some(var_238) = &input.last_observed_at {
let mut array_239 = object.key("LastObservedAt").start_array();
for item_240 in var_238 {
{
#[allow(unused_mut)]
let mut object_241 = array_239.value().start_object();
crate::json_ser::serialize_structure_crate_model_date_filter(
&mut object_241,
item_240,
)?;
object_241.finish();
}
}
array_239.finish();
}
if let Some(var_242) = &input.created_at {
let mut array_243 = object.key("CreatedAt").start_array();
for item_244 in var_242 {
{
#[allow(unused_mut)]
let mut object_245 = array_243.value().start_object();
crate::json_ser::serialize_structure_crate_model_date_filter(
&mut object_245,
item_244,
)?;
object_245.finish();
}
}
array_243.finish();
}
if let Some(var_246) = &input.updated_at {
let mut array_247 = object.key("UpdatedAt").start_array();
for item_248 in var_246 {
{
#[allow(unused_mut)]
let mut object_249 = array_247.value().start_object();
crate::json_ser::serialize_structure_crate_model_date_filter(
&mut object_249,
item_248,
)?;
object_249.finish();
}
}
array_247.finish();
}
if let Some(var_250) = &input.severity_product {
let mut array_251 = object.key("SeverityProduct").start_array();
for item_252 in var_250 {
{
#[allow(unused_mut)]
let mut object_253 = array_251.value().start_object();
crate::json_ser::serialize_structure_crate_model_number_filter(
&mut object_253,
item_252,
)?;
object_253.finish();
}
}
array_251.finish();
}
if let Some(var_254) = &input.severity_normalized {
let mut array_255 = object.key("SeverityNormalized").start_array();
for item_256 in var_254 {
{
#[allow(unused_mut)]
let mut object_257 = array_255.value().start_object();
crate::json_ser::serialize_structure_crate_model_number_filter(
&mut object_257,
item_256,
)?;
object_257.finish();
}
}
array_255.finish();
}
if let Some(var_258) = &input.severity_label {
let mut array_259 = object.key("SeverityLabel").start_array();
for item_260 in var_258 {
{
#[allow(unused_mut)]
let mut object_261 = array_259.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_261,
item_260,
)?;
object_261.finish();
}
}
array_259.finish();
}
if let Some(var_262) = &input.confidence {
let mut array_263 = object.key("Confidence").start_array();
for item_264 in var_262 {
{
#[allow(unused_mut)]
let mut object_265 = array_263.value().start_object();
crate::json_ser::serialize_structure_crate_model_number_filter(
&mut object_265,
item_264,
)?;
object_265.finish();
}
}
array_263.finish();
}
if let Some(var_266) = &input.criticality {
let mut array_267 = object.key("Criticality").start_array();
for item_268 in var_266 {
{
#[allow(unused_mut)]
let mut object_269 = array_267.value().start_object();
crate::json_ser::serialize_structure_crate_model_number_filter(
&mut object_269,
item_268,
)?;
object_269.finish();
}
}
array_267.finish();
}
if let Some(var_270) = &input.title {
let mut array_271 = object.key("Title").start_array();
for item_272 in var_270 {
{
#[allow(unused_mut)]
let mut object_273 = array_271.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_273,
item_272,
)?;
object_273.finish();
}
}
array_271.finish();
}
if let Some(var_274) = &input.description {
let mut array_275 = object.key("Description").start_array();
for item_276 in var_274 {
{
#[allow(unused_mut)]
let mut object_277 = array_275.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_277,
item_276,
)?;
object_277.finish();
}
}
array_275.finish();
}
if let Some(var_278) = &input.recommendation_text {
let mut array_279 = object.key("RecommendationText").start_array();
for item_280 in var_278 {
{
#[allow(unused_mut)]
let mut object_281 = array_279.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_281,
item_280,
)?;
object_281.finish();
}
}
array_279.finish();
}
if let Some(var_282) = &input.source_url {
let mut array_283 = object.key("SourceUrl").start_array();
for item_284 in var_282 {
{
#[allow(unused_mut)]
let mut object_285 = array_283.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_285,
item_284,
)?;
object_285.finish();
}
}
array_283.finish();
}
if let Some(var_286) = &input.product_fields {
let mut array_287 = object.key("ProductFields").start_array();
for item_288 in var_286 {
{
#[allow(unused_mut)]
let mut object_289 = array_287.value().start_object();
crate::json_ser::serialize_structure_crate_model_map_filter(
&mut object_289,
item_288,
)?;
object_289.finish();
}
}
array_287.finish();
}
if let Some(var_290) = &input.product_name {
let mut array_291 = object.key("ProductName").start_array();
for item_292 in var_290 {
{
#[allow(unused_mut)]
let mut object_293 = array_291.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_293,
item_292,
)?;
object_293.finish();
}
}
array_291.finish();
}
if let Some(var_294) = &input.company_name {
let mut array_295 = object.key("CompanyName").start_array();
for item_296 in var_294 {
{
#[allow(unused_mut)]
let mut object_297 = array_295.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_297,
item_296,
)?;
object_297.finish();
}
}
array_295.finish();
}
if let Some(var_298) = &input.user_defined_fields {
let mut array_299 = object.key("UserDefinedFields").start_array();
for item_300 in var_298 {
{
#[allow(unused_mut)]
let mut object_301 = array_299.value().start_object();
crate::json_ser::serialize_structure_crate_model_map_filter(
&mut object_301,
item_300,
)?;
object_301.finish();
}
}
array_299.finish();
}
if let Some(var_302) = &input.malware_name {
let mut array_303 = object.key("MalwareName").start_array();
for item_304 in var_302 {
{
#[allow(unused_mut)]
let mut object_305 = array_303.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_305,
item_304,
)?;
object_305.finish();
}
}
array_303.finish();
}
if let Some(var_306) = &input.malware_type {
let mut array_307 = object.key("MalwareType").start_array();
for item_308 in var_306 {
{
#[allow(unused_mut)]
let mut object_309 = array_307.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_309,
item_308,
)?;
object_309.finish();
}
}
array_307.finish();
}
if let Some(var_310) = &input.malware_path {
let mut array_311 = object.key("MalwarePath").start_array();
for item_312 in var_310 {
{
#[allow(unused_mut)]
let mut object_313 = array_311.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_313,
item_312,
)?;
object_313.finish();
}
}
array_311.finish();
}
if let Some(var_314) = &input.malware_state {
let mut array_315 = object.key("MalwareState").start_array();
for item_316 in var_314 {
{
#[allow(unused_mut)]
let mut object_317 = array_315.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_317,
item_316,
)?;
object_317.finish();
}
}
array_315.finish();
}
if let Some(var_318) = &input.network_direction {
let mut array_319 = object.key("NetworkDirection").start_array();
for item_320 in var_318 {
{
#[allow(unused_mut)]
let mut object_321 = array_319.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_321,
item_320,
)?;
object_321.finish();
}
}
array_319.finish();
}
if let Some(var_322) = &input.network_protocol {
let mut array_323 = object.key("NetworkProtocol").start_array();
for item_324 in var_322 {
{
#[allow(unused_mut)]
let mut object_325 = array_323.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_325,
item_324,
)?;
object_325.finish();
}
}
array_323.finish();
}
if let Some(var_326) = &input.network_source_ip_v4 {
let mut array_327 = object.key("NetworkSourceIpV4").start_array();
for item_328 in var_326 {
{
#[allow(unused_mut)]
let mut object_329 = array_327.value().start_object();
crate::json_ser::serialize_structure_crate_model_ip_filter(
&mut object_329,
item_328,
)?;
object_329.finish();
}
}
array_327.finish();
}
if let Some(var_330) = &input.network_source_ip_v6 {
let mut array_331 = object.key("NetworkSourceIpV6").start_array();
for item_332 in var_330 {
{
#[allow(unused_mut)]
let mut object_333 = array_331.value().start_object();
crate::json_ser::serialize_structure_crate_model_ip_filter(
&mut object_333,
item_332,
)?;
object_333.finish();
}
}
array_331.finish();
}
if let Some(var_334) = &input.network_source_port {
let mut array_335 = object.key("NetworkSourcePort").start_array();
for item_336 in var_334 {
{
#[allow(unused_mut)]
let mut object_337 = array_335.value().start_object();
crate::json_ser::serialize_structure_crate_model_number_filter(
&mut object_337,
item_336,
)?;
object_337.finish();
}
}
array_335.finish();
}
if let Some(var_338) = &input.network_source_domain {
let mut array_339 = object.key("NetworkSourceDomain").start_array();
for item_340 in var_338 {
{
#[allow(unused_mut)]
let mut object_341 = array_339.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_341,
item_340,
)?;
object_341.finish();
}
}
array_339.finish();
}
if let Some(var_342) = &input.network_source_mac {
let mut array_343 = object.key("NetworkSourceMac").start_array();
for item_344 in var_342 {
{
#[allow(unused_mut)]
let mut object_345 = array_343.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_345,
item_344,
)?;
object_345.finish();
}
}
array_343.finish();
}
if let Some(var_346) = &input.network_destination_ip_v4 {
let mut array_347 = object.key("NetworkDestinationIpV4").start_array();
for item_348 in var_346 {
{
#[allow(unused_mut)]
let mut object_349 = array_347.value().start_object();
crate::json_ser::serialize_structure_crate_model_ip_filter(
&mut object_349,
item_348,
)?;
object_349.finish();
}
}
array_347.finish();
}
if let Some(var_350) = &input.network_destination_ip_v6 {
let mut array_351 = object.key("NetworkDestinationIpV6").start_array();
for item_352 in var_350 {
{
#[allow(unused_mut)]
let mut object_353 = array_351.value().start_object();
crate::json_ser::serialize_structure_crate_model_ip_filter(
&mut object_353,
item_352,
)?;
object_353.finish();
}
}
array_351.finish();
}
if let Some(var_354) = &input.network_destination_port {
let mut array_355 = object.key("NetworkDestinationPort").start_array();
for item_356 in var_354 {
{
#[allow(unused_mut)]
let mut object_357 = array_355.value().start_object();
crate::json_ser::serialize_structure_crate_model_number_filter(
&mut object_357,
item_356,
)?;
object_357.finish();
}
}
array_355.finish();
}
if let Some(var_358) = &input.network_destination_domain {
let mut array_359 = object.key("NetworkDestinationDomain").start_array();
for item_360 in var_358 {
{
#[allow(unused_mut)]
let mut object_361 = array_359.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_361,
item_360,
)?;
object_361.finish();
}
}
array_359.finish();
}
if let Some(var_362) = &input.process_name {
let mut array_363 = object.key("ProcessName").start_array();
for item_364 in var_362 {
{
#[allow(unused_mut)]
let mut object_365 = array_363.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_365,
item_364,
)?;
object_365.finish();
}
}
array_363.finish();
}
if let Some(var_366) = &input.process_path {
let mut array_367 = object.key("ProcessPath").start_array();
for item_368 in var_366 {
{
#[allow(unused_mut)]
let mut object_369 = array_367.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_369,
item_368,
)?;
object_369.finish();
}
}
array_367.finish();
}
if let Some(var_370) = &input.process_pid {
let mut array_371 = object.key("ProcessPid").start_array();
for item_372 in var_370 {
{
#[allow(unused_mut)]
let mut object_373 = array_371.value().start_object();
crate::json_ser::serialize_structure_crate_model_number_filter(
&mut object_373,
item_372,
)?;
object_373.finish();
}
}
array_371.finish();
}
if let Some(var_374) = &input.process_parent_pid {
let mut array_375 = object.key("ProcessParentPid").start_array();
for item_376 in var_374 {
{
#[allow(unused_mut)]
let mut object_377 = array_375.value().start_object();
crate::json_ser::serialize_structure_crate_model_number_filter(
&mut object_377,
item_376,
)?;
object_377.finish();
}
}
array_375.finish();
}
if let Some(var_378) = &input.process_launched_at {
let mut array_379 = object.key("ProcessLaunchedAt").start_array();
for item_380 in var_378 {
{
#[allow(unused_mut)]
let mut object_381 = array_379.value().start_object();
crate::json_ser::serialize_structure_crate_model_date_filter(
&mut object_381,
item_380,
)?;
object_381.finish();
}
}
array_379.finish();
}
if let Some(var_382) = &input.process_terminated_at {
let mut array_383 = object.key("ProcessTerminatedAt").start_array();
for item_384 in var_382 {
{
#[allow(unused_mut)]
let mut object_385 = array_383.value().start_object();
crate::json_ser::serialize_structure_crate_model_date_filter(
&mut object_385,
item_384,
)?;
object_385.finish();
}
}
array_383.finish();
}
if let Some(var_386) = &input.threat_intel_indicator_type {
let mut array_387 = object.key("ThreatIntelIndicatorType").start_array();
for item_388 in var_386 {
{
#[allow(unused_mut)]
let mut object_389 = array_387.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_389,
item_388,
)?;
object_389.finish();
}
}
array_387.finish();
}
if let Some(var_390) = &input.threat_intel_indicator_value {
let mut array_391 = object.key("ThreatIntelIndicatorValue").start_array();
for item_392 in var_390 {
{
#[allow(unused_mut)]
let mut object_393 = array_391.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_393,
item_392,
)?;
object_393.finish();
}
}
array_391.finish();
}
if let Some(var_394) = &input.threat_intel_indicator_category {
let mut array_395 = object.key("ThreatIntelIndicatorCategory").start_array();
for item_396 in var_394 {
{
#[allow(unused_mut)]
let mut object_397 = array_395.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_397,
item_396,
)?;
object_397.finish();
}
}
array_395.finish();
}
if let Some(var_398) = &input.threat_intel_indicator_last_observed_at {
let mut array_399 = object
.key("ThreatIntelIndicatorLastObservedAt")
.start_array();
for item_400 in var_398 {
{
#[allow(unused_mut)]
let mut object_401 = array_399.value().start_object();
crate::json_ser::serialize_structure_crate_model_date_filter(
&mut object_401,
item_400,
)?;
object_401.finish();
}
}
array_399.finish();
}
if let Some(var_402) = &input.threat_intel_indicator_source {
let mut array_403 = object.key("ThreatIntelIndicatorSource").start_array();
for item_404 in var_402 {
{
#[allow(unused_mut)]
let mut object_405 = array_403.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_405,
item_404,
)?;
object_405.finish();
}
}
array_403.finish();
}
if let Some(var_406) = &input.threat_intel_indicator_source_url {
let mut array_407 = object.key("ThreatIntelIndicatorSourceUrl").start_array();
for item_408 in var_406 {
{
#[allow(unused_mut)]
let mut object_409 = array_407.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_409,
item_408,
)?;
object_409.finish();
}
}
array_407.finish();
}
if let Some(var_410) = &input.resource_type {
let mut array_411 = object.key("ResourceType").start_array();
for item_412 in var_410 {
{
#[allow(unused_mut)]
let mut object_413 = array_411.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_413,
item_412,
)?;
object_413.finish();
}
}
array_411.finish();
}
if let Some(var_414) = &input.resource_id {
let mut array_415 = object.key("ResourceId").start_array();
for item_416 in var_414 {
{
#[allow(unused_mut)]
let mut object_417 = array_415.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_417,
item_416,
)?;
object_417.finish();
}
}
array_415.finish();
}
if let Some(var_418) = &input.resource_partition {
let mut array_419 = object.key("ResourcePartition").start_array();
for item_420 in var_418 {
{
#[allow(unused_mut)]
let mut object_421 = array_419.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_421,
item_420,
)?;
object_421.finish();
}
}
array_419.finish();
}
if let Some(var_422) = &input.resource_region {
let mut array_423 = object.key("ResourceRegion").start_array();
for item_424 in var_422 {
{
#[allow(unused_mut)]
let mut object_425 = array_423.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_425,
item_424,
)?;
object_425.finish();
}
}
array_423.finish();
}
if let Some(var_426) = &input.resource_tags {
let mut array_427 = object.key("ResourceTags").start_array();
for item_428 in var_426 {
{
#[allow(unused_mut)]
let mut object_429 = array_427.value().start_object();
crate::json_ser::serialize_structure_crate_model_map_filter(
&mut object_429,
item_428,
)?;
object_429.finish();
}
}
array_427.finish();
}
if let Some(var_430) = &input.resource_aws_ec2_instance_type {
let mut array_431 = object.key("ResourceAwsEc2InstanceType").start_array();
for item_432 in var_430 {
{
#[allow(unused_mut)]
let mut object_433 = array_431.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_433,
item_432,
)?;
object_433.finish();
}
}
array_431.finish();
}
if let Some(var_434) = &input.resource_aws_ec2_instance_image_id {
let mut array_435 = object.key("ResourceAwsEc2InstanceImageId").start_array();
for item_436 in var_434 {
{
#[allow(unused_mut)]
let mut object_437 = array_435.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_437,
item_436,
)?;
object_437.finish();
}
}
array_435.finish();
}
if let Some(var_438) = &input.resource_aws_ec2_instance_ip_v4_addresses {
let mut array_439 = object
.key("ResourceAwsEc2InstanceIpV4Addresses")
.start_array();
for item_440 in var_438 {
{
#[allow(unused_mut)]
let mut object_441 = array_439.value().start_object();
crate::json_ser::serialize_structure_crate_model_ip_filter(
&mut object_441,
item_440,
)?;
object_441.finish();
}
}
array_439.finish();
}
if let Some(var_442) = &input.resource_aws_ec2_instance_ip_v6_addresses {
let mut array_443 = object
.key("ResourceAwsEc2InstanceIpV6Addresses")
.start_array();
for item_444 in var_442 {
{
#[allow(unused_mut)]
let mut object_445 = array_443.value().start_object();
crate::json_ser::serialize_structure_crate_model_ip_filter(
&mut object_445,
item_444,
)?;
object_445.finish();
}
}
array_443.finish();
}
if let Some(var_446) = &input.resource_aws_ec2_instance_key_name {
let mut array_447 = object.key("ResourceAwsEc2InstanceKeyName").start_array();
for item_448 in var_446 {
{
#[allow(unused_mut)]
let mut object_449 = array_447.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_449,
item_448,
)?;
object_449.finish();
}
}
array_447.finish();
}
if let Some(var_450) = &input.resource_aws_ec2_instance_iam_instance_profile_arn {
let mut array_451 = object
.key("ResourceAwsEc2InstanceIamInstanceProfileArn")
.start_array();
for item_452 in var_450 {
{
#[allow(unused_mut)]
let mut object_453 = array_451.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_453,
item_452,
)?;
object_453.finish();
}
}
array_451.finish();
}
if let Some(var_454) = &input.resource_aws_ec2_instance_vpc_id {
let mut array_455 = object.key("ResourceAwsEc2InstanceVpcId").start_array();
for item_456 in var_454 {
{
#[allow(unused_mut)]
let mut object_457 = array_455.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_457,
item_456,
)?;
object_457.finish();
}
}
array_455.finish();
}
if let Some(var_458) = &input.resource_aws_ec2_instance_subnet_id {
let mut array_459 = object.key("ResourceAwsEc2InstanceSubnetId").start_array();
for item_460 in var_458 {
{
#[allow(unused_mut)]
let mut object_461 = array_459.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_461,
item_460,
)?;
object_461.finish();
}
}
array_459.finish();
}
if let Some(var_462) = &input.resource_aws_ec2_instance_launched_at {
let mut array_463 = object.key("ResourceAwsEc2InstanceLaunchedAt").start_array();
for item_464 in var_462 {
{
#[allow(unused_mut)]
let mut object_465 = array_463.value().start_object();
crate::json_ser::serialize_structure_crate_model_date_filter(
&mut object_465,
item_464,
)?;
object_465.finish();
}
}
array_463.finish();
}
if let Some(var_466) = &input.resource_aws_s3_bucket_owner_id {
let mut array_467 = object.key("ResourceAwsS3BucketOwnerId").start_array();
for item_468 in var_466 {
{
#[allow(unused_mut)]
let mut object_469 = array_467.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_469,
item_468,
)?;
object_469.finish();
}
}
array_467.finish();
}
if let Some(var_470) = &input.resource_aws_s3_bucket_owner_name {
let mut array_471 = object.key("ResourceAwsS3BucketOwnerName").start_array();
for item_472 in var_470 {
{
#[allow(unused_mut)]
let mut object_473 = array_471.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_473,
item_472,
)?;
object_473.finish();
}
}
array_471.finish();
}
if let Some(var_474) = &input.resource_aws_iam_access_key_user_name {
let mut array_475 = object.key("ResourceAwsIamAccessKeyUserName").start_array();
for item_476 in var_474 {
{
#[allow(unused_mut)]
let mut object_477 = array_475.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_477,
item_476,
)?;
object_477.finish();
}
}
array_475.finish();
}
if let Some(var_478) = &input.resource_aws_iam_access_key_principal_name {
let mut array_479 = object
.key("ResourceAwsIamAccessKeyPrincipalName")
.start_array();
for item_480 in var_478 {
{
#[allow(unused_mut)]
let mut object_481 = array_479.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_481,
item_480,
)?;
object_481.finish();
}
}
array_479.finish();
}
if let Some(var_482) = &input.resource_aws_iam_access_key_status {
let mut array_483 = object.key("ResourceAwsIamAccessKeyStatus").start_array();
for item_484 in var_482 {
{
#[allow(unused_mut)]
let mut object_485 = array_483.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_485,
item_484,
)?;
object_485.finish();
}
}
array_483.finish();
}
if let Some(var_486) = &input.resource_aws_iam_access_key_created_at {
let mut array_487 = object.key("ResourceAwsIamAccessKeyCreatedAt").start_array();
for item_488 in var_486 {
{
#[allow(unused_mut)]
let mut object_489 = array_487.value().start_object();
crate::json_ser::serialize_structure_crate_model_date_filter(
&mut object_489,
item_488,
)?;
object_489.finish();
}
}
array_487.finish();
}
if let Some(var_490) = &input.resource_aws_iam_user_user_name {
let mut array_491 = object.key("ResourceAwsIamUserUserName").start_array();
for item_492 in var_490 {
{
#[allow(unused_mut)]
let mut object_493 = array_491.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_493,
item_492,
)?;
object_493.finish();
}
}
array_491.finish();
}
if let Some(var_494) = &input.resource_container_name {
let mut array_495 = object.key("ResourceContainerName").start_array();
for item_496 in var_494 {
{
#[allow(unused_mut)]
let mut object_497 = array_495.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_497,
item_496,
)?;
object_497.finish();
}
}
array_495.finish();
}
if let Some(var_498) = &input.resource_container_image_id {
let mut array_499 = object.key("ResourceContainerImageId").start_array();
for item_500 in var_498 {
{
#[allow(unused_mut)]
let mut object_501 = array_499.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_501,
item_500,
)?;
object_501.finish();
}
}
array_499.finish();
}
if let Some(var_502) = &input.resource_container_image_name {
let mut array_503 = object.key("ResourceContainerImageName").start_array();
for item_504 in var_502 {
{
#[allow(unused_mut)]
let mut object_505 = array_503.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_505,
item_504,
)?;
object_505.finish();
}
}
array_503.finish();
}
if let Some(var_506) = &input.resource_container_launched_at {
let mut array_507 = object.key("ResourceContainerLaunchedAt").start_array();
for item_508 in var_506 {
{
#[allow(unused_mut)]
let mut object_509 = array_507.value().start_object();
crate::json_ser::serialize_structure_crate_model_date_filter(
&mut object_509,
item_508,
)?;
object_509.finish();
}
}
array_507.finish();
}
if let Some(var_510) = &input.resource_details_other {
let mut array_511 = object.key("ResourceDetailsOther").start_array();
for item_512 in var_510 {
{
#[allow(unused_mut)]
let mut object_513 = array_511.value().start_object();
crate::json_ser::serialize_structure_crate_model_map_filter(
&mut object_513,
item_512,
)?;
object_513.finish();
}
}
array_511.finish();
}
if let Some(var_514) = &input.compliance_status {
let mut array_515 = object.key("ComplianceStatus").start_array();
for item_516 in var_514 {
{
#[allow(unused_mut)]
let mut object_517 = array_515.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_517,
item_516,
)?;
object_517.finish();
}
}
array_515.finish();
}
if let Some(var_518) = &input.verification_state {
let mut array_519 = object.key("VerificationState").start_array();
for item_520 in var_518 {
{
#[allow(unused_mut)]
let mut object_521 = array_519.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_521,
item_520,
)?;
object_521.finish();
}
}
array_519.finish();
}
if let Some(var_522) = &input.workflow_state {
let mut array_523 = object.key("WorkflowState").start_array();
for item_524 in var_522 {
{
#[allow(unused_mut)]
let mut object_525 = array_523.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_525,
item_524,
)?;
object_525.finish();
}
}
array_523.finish();
}
if let Some(var_526) = &input.workflow_status {
let mut array_527 = object.key("WorkflowStatus").start_array();
for item_528 in var_526 {
{
#[allow(unused_mut)]
let mut object_529 = array_527.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_529,
item_528,
)?;
object_529.finish();
}
}
array_527.finish();
}
if let Some(var_530) = &input.record_state {
let mut array_531 = object.key("RecordState").start_array();
for item_532 in var_530 {
{
#[allow(unused_mut)]
let mut object_533 = array_531.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_533,
item_532,
)?;
object_533.finish();
}
}
array_531.finish();
}
if let Some(var_534) = &input.related_findings_product_arn {
let mut array_535 = object.key("RelatedFindingsProductArn").start_array();
for item_536 in var_534 {
{
#[allow(unused_mut)]
let mut object_537 = array_535.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_537,
item_536,
)?;
object_537.finish();
}
}
array_535.finish();
}
if let Some(var_538) = &input.related_findings_id {
let mut array_539 = object.key("RelatedFindingsId").start_array();
for item_540 in var_538 {
{
#[allow(unused_mut)]
let mut object_541 = array_539.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_541,
item_540,
)?;
object_541.finish();
}
}
array_539.finish();
}
if let Some(var_542) = &input.note_text {
let mut array_543 = object.key("NoteText").start_array();
for item_544 in var_542 {
{
#[allow(unused_mut)]
let mut object_545 = array_543.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_545,
item_544,
)?;
object_545.finish();
}
}
array_543.finish();
}
if let Some(var_546) = &input.note_updated_at {
let mut array_547 = object.key("NoteUpdatedAt").start_array();
for item_548 in var_546 {
{
#[allow(unused_mut)]
let mut object_549 = array_547.value().start_object();
crate::json_ser::serialize_structure_crate_model_date_filter(
&mut object_549,
item_548,
)?;
object_549.finish();
}
}
array_547.finish();
}
if let Some(var_550) = &input.note_updated_by {
let mut array_551 = object.key("NoteUpdatedBy").start_array();
for item_552 in var_550 {
{
#[allow(unused_mut)]
let mut object_553 = array_551.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_553,
item_552,
)?;
object_553.finish();
}
}
array_551.finish();
}
if let Some(var_554) = &input.keyword {
let mut array_555 = object.key("Keyword").start_array();
for item_556 in var_554 {
{
#[allow(unused_mut)]
let mut object_557 = array_555.value().start_object();
crate::json_ser::serialize_structure_crate_model_keyword_filter(
&mut object_557,
item_556,
)?;
object_557.finish();
}
}
array_555.finish();
}
if let Some(var_558) = &input.finding_provider_fields_confidence {
let mut array_559 = object.key("FindingProviderFieldsConfidence").start_array();
for item_560 in var_558 {
{
#[allow(unused_mut)]
let mut object_561 = array_559.value().start_object();
crate::json_ser::serialize_structure_crate_model_number_filter(
&mut object_561,
item_560,
)?;
object_561.finish();
}
}
array_559.finish();
}
if let Some(var_562) = &input.finding_provider_fields_criticality {
let mut array_563 = object.key("FindingProviderFieldsCriticality").start_array();
for item_564 in var_562 {
{
#[allow(unused_mut)]
let mut object_565 = array_563.value().start_object();
crate::json_ser::serialize_structure_crate_model_number_filter(
&mut object_565,
item_564,
)?;
object_565.finish();
}
}
array_563.finish();
}
if let Some(var_566) = &input.finding_provider_fields_related_findings_id {
let mut array_567 = object
.key("FindingProviderFieldsRelatedFindingsId")
.start_array();
for item_568 in var_566 {
{
#[allow(unused_mut)]
let mut object_569 = array_567.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_569,
item_568,
)?;
object_569.finish();
}
}
array_567.finish();
}
if let Some(var_570) = &input.finding_provider_fields_related_findings_product_arn {
let mut array_571 = object
.key("FindingProviderFieldsRelatedFindingsProductArn")
.start_array();
for item_572 in var_570 {
{
#[allow(unused_mut)]
let mut object_573 = array_571.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_573,
item_572,
)?;
object_573.finish();
}
}
array_571.finish();
}
if let Some(var_574) = &input.finding_provider_fields_severity_label {
let mut array_575 = object
.key("FindingProviderFieldsSeverityLabel")
.start_array();
for item_576 in var_574 {
{
#[allow(unused_mut)]
let mut object_577 = array_575.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_577,
item_576,
)?;
object_577.finish();
}
}
array_575.finish();
}
if let Some(var_578) = &input.finding_provider_fields_severity_original {
let mut array_579 = object
.key("FindingProviderFieldsSeverityOriginal")
.start_array();
for item_580 in var_578 {
{
#[allow(unused_mut)]
let mut object_581 = array_579.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_581,
item_580,
)?;
object_581.finish();
}
}
array_579.finish();
}
if let Some(var_582) = &input.finding_provider_fields_types {
let mut array_583 = object.key("FindingProviderFieldsTypes").start_array();
for item_584 in var_582 {
{
#[allow(unused_mut)]
let mut object_585 = array_583.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_filter(
&mut object_585,
item_584,
)?;
object_585.finish();
}
}
array_583.finish();
}
if let Some(var_586) = &input.sample {
let mut array_587 = object.key("Sample").start_array();
for item_588 in var_586 {
{
#[allow(unused_mut)]
let mut object_589 = array_587.value().start_object();
crate::json_ser::serialize_structure_crate_model_boolean_filter(
&mut object_589,
item_588,
)?;
object_589.finish();
}
}
array_587.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_account_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AccountDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_590) = &input.account_id {
object.key("AccountId").string(var_590.as_str());
}
if let Some(var_591) = &input.email {
object.key("Email").string(var_591.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sort_criterion(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SortCriterion,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_592) = &input.field {
object.key("Field").string(var_592.as_str());
}
if let Some(var_593) = &input.sort_order {
object.key("SortOrder").string(var_593.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_severity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Severity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.product != 0.0 {
object.key("Product").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.product).into()),
);
}
if let Some(var_594) = &input.label {
object.key("Label").string(var_594.as_str());
}
if input.normalized != 0 {
object.key("Normalized").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.normalized).into()),
);
}
if let Some(var_595) = &input.original {
object.key("Original").string(var_595.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_remediation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Remediation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_596) = &input.recommendation {
#[allow(unused_mut)]
let mut object_597 = object.key("Recommendation").start_object();
crate::json_ser::serialize_structure_crate_model_recommendation(&mut object_597, var_596)?;
object_597.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_malware(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Malware,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_598) = &input.name {
object.key("Name").string(var_598.as_str());
}
if let Some(var_599) = &input.r#type {
object.key("Type").string(var_599.as_str());
}
if let Some(var_600) = &input.path {
object.key("Path").string(var_600.as_str());
}
if let Some(var_601) = &input.state {
object.key("State").string(var_601.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_network(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Network,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_602) = &input.direction {
object.key("Direction").string(var_602.as_str());
}
if let Some(var_603) = &input.protocol {
object.key("Protocol").string(var_603.as_str());
}
if let Some(var_604) = &input.open_port_range {
#[allow(unused_mut)]
let mut object_605 = object.key("OpenPortRange").start_object();
crate::json_ser::serialize_structure_crate_model_port_range(&mut object_605, var_604)?;
object_605.finish();
}
if let Some(var_606) = &input.source_ip_v4 {
object.key("SourceIpV4").string(var_606.as_str());
}
if let Some(var_607) = &input.source_ip_v6 {
object.key("SourceIpV6").string(var_607.as_str());
}
if input.source_port != 0 {
object.key("SourcePort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.source_port).into()),
);
}
if let Some(var_608) = &input.source_domain {
object.key("SourceDomain").string(var_608.as_str());
}
if let Some(var_609) = &input.source_mac {
object.key("SourceMac").string(var_609.as_str());
}
if let Some(var_610) = &input.destination_ip_v4 {
object.key("DestinationIpV4").string(var_610.as_str());
}
if let Some(var_611) = &input.destination_ip_v6 {
object.key("DestinationIpV6").string(var_611.as_str());
}
if input.destination_port != 0 {
object.key("DestinationPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.destination_port).into()),
);
}
if let Some(var_612) = &input.destination_domain {
object.key("DestinationDomain").string(var_612.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_network_path_component(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NetworkPathComponent,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_613) = &input.component_id {
object.key("ComponentId").string(var_613.as_str());
}
if let Some(var_614) = &input.component_type {
object.key("ComponentType").string(var_614.as_str());
}
if let Some(var_615) = &input.egress {
#[allow(unused_mut)]
let mut object_616 = object.key("Egress").start_object();
crate::json_ser::serialize_structure_crate_model_network_header(&mut object_616, var_615)?;
object_616.finish();
}
if let Some(var_617) = &input.ingress {
#[allow(unused_mut)]
let mut object_618 = object.key("Ingress").start_object();
crate::json_ser::serialize_structure_crate_model_network_header(&mut object_618, var_617)?;
object_618.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_process_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProcessDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_619) = &input.name {
object.key("Name").string(var_619.as_str());
}
if let Some(var_620) = &input.path {
object.key("Path").string(var_620.as_str());
}
if input.pid != 0 {
object.key("Pid").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.pid).into()),
);
}
if input.parent_pid != 0 {
object.key("ParentPid").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.parent_pid).into()),
);
}
if let Some(var_621) = &input.launched_at {
object.key("LaunchedAt").string(var_621.as_str());
}
if let Some(var_622) = &input.terminated_at {
object.key("TerminatedAt").string(var_622.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_threat(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Threat,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_623) = &input.name {
object.key("Name").string(var_623.as_str());
}
if let Some(var_624) = &input.severity {
object.key("Severity").string(var_624.as_str());
}
if input.item_count != 0 {
object.key("ItemCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.item_count).into()),
);
}
if let Some(var_625) = &input.file_paths {
let mut array_626 = object.key("FilePaths").start_array();
for item_627 in var_625 {
{
#[allow(unused_mut)]
let mut object_628 = array_626.value().start_object();
crate::json_ser::serialize_structure_crate_model_file_paths(
&mut object_628,
item_627,
)?;
object_628.finish();
}
}
array_626.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_threat_intel_indicator(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ThreatIntelIndicator,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_629) = &input.r#type {
object.key("Type").string(var_629.as_str());
}
if let Some(var_630) = &input.value {
object.key("Value").string(var_630.as_str());
}
if let Some(var_631) = &input.category {
object.key("Category").string(var_631.as_str());
}
if let Some(var_632) = &input.last_observed_at {
object.key("LastObservedAt").string(var_632.as_str());
}
if let Some(var_633) = &input.source {
object.key("Source").string(var_633.as_str());
}
if let Some(var_634) = &input.source_url {
object.key("SourceUrl").string(var_634.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_resource(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Resource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_635) = &input.r#type {
object.key("Type").string(var_635.as_str());
}
if let Some(var_636) = &input.id {
object.key("Id").string(var_636.as_str());
}
if let Some(var_637) = &input.partition {
object.key("Partition").string(var_637.as_str());
}
if let Some(var_638) = &input.region {
object.key("Region").string(var_638.as_str());
}
if let Some(var_639) = &input.resource_role {
object.key("ResourceRole").string(var_639.as_str());
}
if let Some(var_640) = &input.tags {
#[allow(unused_mut)]
let mut object_641 = object.key("Tags").start_object();
for (key_642, value_643) in var_640 {
{
object_641.key(key_642.as_str()).string(value_643.as_str());
}
}
object_641.finish();
}
if let Some(var_644) = &input.data_classification {
#[allow(unused_mut)]
let mut object_645 = object.key("DataClassification").start_object();
crate::json_ser::serialize_structure_crate_model_data_classification_details(
&mut object_645,
var_644,
)?;
object_645.finish();
}
if let Some(var_646) = &input.details {
#[allow(unused_mut)]
let mut object_647 = object.key("Details").start_object();
crate::json_ser::serialize_structure_crate_model_resource_details(
&mut object_647,
var_646,
)?;
object_647.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_compliance(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Compliance,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_648) = &input.status {
object.key("Status").string(var_648.as_str());
}
if let Some(var_649) = &input.related_requirements {
let mut array_650 = object.key("RelatedRequirements").start_array();
for item_651 in var_649 {
{
array_650.value().string(item_651.as_str());
}
}
array_650.finish();
}
if let Some(var_652) = &input.status_reasons {
let mut array_653 = object.key("StatusReasons").start_array();
for item_654 in var_652 {
{
#[allow(unused_mut)]
let mut object_655 = array_653.value().start_object();
crate::json_ser::serialize_structure_crate_model_status_reason(
&mut object_655,
item_654,
)?;
object_655.finish();
}
}
array_653.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_workflow(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Workflow,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_656) = &input.status {
object.key("Status").string(var_656.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_note(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Note,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_657) = &input.text {
object.key("Text").string(var_657.as_str());
}
if let Some(var_658) = &input.updated_by {
object.key("UpdatedBy").string(var_658.as_str());
}
if let Some(var_659) = &input.updated_at {
object.key("UpdatedAt").string(var_659.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_vulnerability(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Vulnerability,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_660) = &input.id {
object.key("Id").string(var_660.as_str());
}
if let Some(var_661) = &input.vulnerable_packages {
let mut array_662 = object.key("VulnerablePackages").start_array();
for item_663 in var_661 {
{
#[allow(unused_mut)]
let mut object_664 = array_662.value().start_object();
crate::json_ser::serialize_structure_crate_model_software_package(
&mut object_664,
item_663,
)?;
object_664.finish();
}
}
array_662.finish();
}
if let Some(var_665) = &input.cvss {
let mut array_666 = object.key("Cvss").start_array();
for item_667 in var_665 {
{
#[allow(unused_mut)]
let mut object_668 = array_666.value().start_object();
crate::json_ser::serialize_structure_crate_model_cvss(&mut object_668, item_667)?;
object_668.finish();
}
}
array_666.finish();
}
if let Some(var_669) = &input.related_vulnerabilities {
let mut array_670 = object.key("RelatedVulnerabilities").start_array();
for item_671 in var_669 {
{
array_670.value().string(item_671.as_str());
}
}
array_670.finish();
}
if let Some(var_672) = &input.vendor {
#[allow(unused_mut)]
let mut object_673 = object.key("Vendor").start_object();
crate::json_ser::serialize_structure_crate_model_vulnerability_vendor(
&mut object_673,
var_672,
)?;
object_673.finish();
}
if let Some(var_674) = &input.reference_urls {
let mut array_675 = object.key("ReferenceUrls").start_array();
for item_676 in var_674 {
{
array_675.value().string(item_676.as_str());
}
}
array_675.finish();
}
if let Some(var_677) = &input.fix_available {
object.key("FixAvailable").string(var_677.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_patch_summary(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PatchSummary,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_678) = &input.id {
object.key("Id").string(var_678.as_str());
}
if input.installed_count != 0 {
object.key("InstalledCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.installed_count).into()),
);
}
if input.missing_count != 0 {
object.key("MissingCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.missing_count).into()),
);
}
if input.failed_count != 0 {
object.key("FailedCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.failed_count).into()),
);
}
if input.installed_other_count != 0 {
object.key("InstalledOtherCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.installed_other_count).into()),
);
}
if input.installed_rejected_count != 0 {
object.key("InstalledRejectedCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.installed_rejected_count).into()),
);
}
if input.installed_pending_reboot != 0 {
object.key("InstalledPendingReboot").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.installed_pending_reboot).into()),
);
}
if let Some(var_679) = &input.operation_start_time {
object.key("OperationStartTime").string(var_679.as_str());
}
if let Some(var_680) = &input.operation_end_time {
object.key("OperationEndTime").string(var_680.as_str());
}
if let Some(var_681) = &input.reboot_option {
object.key("RebootOption").string(var_681.as_str());
}
if let Some(var_682) = &input.operation {
object.key("Operation").string(var_682.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Action,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_683) = &input.action_type {
object.key("ActionType").string(var_683.as_str());
}
if let Some(var_684) = &input.network_connection_action {
#[allow(unused_mut)]
let mut object_685 = object.key("NetworkConnectionAction").start_object();
crate::json_ser::serialize_structure_crate_model_network_connection_action(
&mut object_685,
var_684,
)?;
object_685.finish();
}
if let Some(var_686) = &input.aws_api_call_action {
#[allow(unused_mut)]
let mut object_687 = object.key("AwsApiCallAction").start_object();
crate::json_ser::serialize_structure_crate_model_aws_api_call_action(
&mut object_687,
var_686,
)?;
object_687.finish();
}
if let Some(var_688) = &input.dns_request_action {
#[allow(unused_mut)]
let mut object_689 = object.key("DnsRequestAction").start_object();
crate::json_ser::serialize_structure_crate_model_dns_request_action(
&mut object_689,
var_688,
)?;
object_689.finish();
}
if let Some(var_690) = &input.port_probe_action {
#[allow(unused_mut)]
let mut object_691 = object.key("PortProbeAction").start_object();
crate::json_ser::serialize_structure_crate_model_port_probe_action(
&mut object_691,
var_690,
)?;
object_691.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_finding_provider_fields(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FindingProviderFields,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.confidence != 0 {
object.key("Confidence").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.confidence).into()),
);
}
if input.criticality != 0 {
object.key("Criticality").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.criticality).into()),
);
}
if let Some(var_692) = &input.related_findings {
let mut array_693 = object.key("RelatedFindings").start_array();
for item_694 in var_692 {
{
#[allow(unused_mut)]
let mut object_695 = array_693.value().start_object();
crate::json_ser::serialize_structure_crate_model_related_finding(
&mut object_695,
item_694,
)?;
object_695.finish();
}
}
array_693.finish();
}
if let Some(var_696) = &input.severity {
#[allow(unused_mut)]
let mut object_697 = object.key("Severity").start_object();
crate::json_ser::serialize_structure_crate_model_finding_provider_severity(
&mut object_697,
var_696,
)?;
object_697.finish();
}
if let Some(var_698) = &input.types {
let mut array_699 = object.key("Types").start_array();
for item_700 in var_698 {
{
array_699.value().string(item_700.as_str());
}
}
array_699.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_string_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StringFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_701) = &input.value {
object.key("Value").string(var_701.as_str());
}
if let Some(var_702) = &input.comparison {
object.key("Comparison").string(var_702.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_date_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DateFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_703) = &input.start {
object.key("Start").string(var_703.as_str());
}
if let Some(var_704) = &input.end {
object.key("End").string(var_704.as_str());
}
if let Some(var_705) = &input.date_range {
#[allow(unused_mut)]
let mut object_706 = object.key("DateRange").start_object();
crate::json_ser::serialize_structure_crate_model_date_range(&mut object_706, var_705)?;
object_706.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_number_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NumberFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.gte != 0.0 {
object.key("Gte").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.gte).into()),
);
}
if input.lte != 0.0 {
object.key("Lte").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.lte).into()),
);
}
if input.eq != 0.0 {
object.key("Eq").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.eq).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_map_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MapFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_707) = &input.key {
object.key("Key").string(var_707.as_str());
}
if let Some(var_708) = &input.value {
object.key("Value").string(var_708.as_str());
}
if let Some(var_709) = &input.comparison {
object.key("Comparison").string(var_709.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ip_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IpFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_710) = &input.cidr {
object.key("Cidr").string(var_710.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_keyword_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KeywordFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_711) = &input.value {
object.key("Value").string(var_711.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_boolean_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BooleanFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.value {
object.key("Value").boolean(input.value);
}
Ok(())
}
pub fn serialize_structure_crate_model_recommendation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Recommendation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_712) = &input.text {
object.key("Text").string(var_712.as_str());
}
if let Some(var_713) = &input.url {
object.key("Url").string(var_713.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_port_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PortRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.begin != 0 {
object.key("Begin").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.begin).into()),
);
}
if input.end != 0 {
object.key("End").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.end).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_network_header(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NetworkHeader,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_714) = &input.protocol {
object.key("Protocol").string(var_714.as_str());
}
if let Some(var_715) = &input.destination {
#[allow(unused_mut)]
let mut object_716 = object.key("Destination").start_object();
crate::json_ser::serialize_structure_crate_model_network_path_component_details(
&mut object_716,
var_715,
)?;
object_716.finish();
}
if let Some(var_717) = &input.source {
#[allow(unused_mut)]
let mut object_718 = object.key("Source").start_object();
crate::json_ser::serialize_structure_crate_model_network_path_component_details(
&mut object_718,
var_717,
)?;
object_718.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_file_paths(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilePaths,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_719) = &input.file_path {
object.key("FilePath").string(var_719.as_str());
}
if let Some(var_720) = &input.file_name {
object.key("FileName").string(var_720.as_str());
}
if let Some(var_721) = &input.resource_id {
object.key("ResourceId").string(var_721.as_str());
}
if let Some(var_722) = &input.hash {
object.key("Hash").string(var_722.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_data_classification_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataClassificationDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_723) = &input.detailed_results_location {
object
.key("DetailedResultsLocation")
.string(var_723.as_str());
}
if let Some(var_724) = &input.result {
#[allow(unused_mut)]
let mut object_725 = object.key("Result").start_object();
crate::json_ser::serialize_structure_crate_model_classification_result(
&mut object_725,
var_724,
)?;
object_725.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourceDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_726) = &input.aws_auto_scaling_auto_scaling_group {
#[allow(unused_mut)]
let mut object_727 = object.key("AwsAutoScalingAutoScalingGroup").start_object();
crate::json_ser::serialize_structure_crate_model_aws_auto_scaling_auto_scaling_group_details(&mut object_727, var_726)?;
object_727.finish();
}
if let Some(var_728) = &input.aws_code_build_project {
#[allow(unused_mut)]
let mut object_729 = object.key("AwsCodeBuildProject").start_object();
crate::json_ser::serialize_structure_crate_model_aws_code_build_project_details(
&mut object_729,
var_728,
)?;
object_729.finish();
}
if let Some(var_730) = &input.aws_cloud_front_distribution {
#[allow(unused_mut)]
let mut object_731 = object.key("AwsCloudFrontDistribution").start_object();
crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_details(
&mut object_731,
var_730,
)?;
object_731.finish();
}
if let Some(var_732) = &input.aws_ec2_instance {
#[allow(unused_mut)]
let mut object_733 = object.key("AwsEc2Instance").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_instance_details(
&mut object_733,
var_732,
)?;
object_733.finish();
}
if let Some(var_734) = &input.aws_ec2_network_interface {
#[allow(unused_mut)]
let mut object_735 = object.key("AwsEc2NetworkInterface").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_network_interface_details(
&mut object_735,
var_734,
)?;
object_735.finish();
}
if let Some(var_736) = &input.aws_ec2_security_group {
#[allow(unused_mut)]
let mut object_737 = object.key("AwsEc2SecurityGroup").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_security_group_details(
&mut object_737,
var_736,
)?;
object_737.finish();
}
if let Some(var_738) = &input.aws_ec2_volume {
#[allow(unused_mut)]
let mut object_739 = object.key("AwsEc2Volume").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_volume_details(
&mut object_739,
var_738,
)?;
object_739.finish();
}
if let Some(var_740) = &input.aws_ec2_vpc {
#[allow(unused_mut)]
let mut object_741 = object.key("AwsEc2Vpc").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_vpc_details(
&mut object_741,
var_740,
)?;
object_741.finish();
}
if let Some(var_742) = &input.aws_ec2_eip {
#[allow(unused_mut)]
let mut object_743 = object.key("AwsEc2Eip").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_eip_details(
&mut object_743,
var_742,
)?;
object_743.finish();
}
if let Some(var_744) = &input.aws_ec2_subnet {
#[allow(unused_mut)]
let mut object_745 = object.key("AwsEc2Subnet").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_subnet_details(
&mut object_745,
var_744,
)?;
object_745.finish();
}
if let Some(var_746) = &input.aws_ec2_network_acl {
#[allow(unused_mut)]
let mut object_747 = object.key("AwsEc2NetworkAcl").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_network_acl_details(
&mut object_747,
var_746,
)?;
object_747.finish();
}
if let Some(var_748) = &input.aws_elbv2_load_balancer {
#[allow(unused_mut)]
let mut object_749 = object.key("AwsElbv2LoadBalancer").start_object();
crate::json_ser::serialize_structure_crate_model_aws_elbv2_load_balancer_details(
&mut object_749,
var_748,
)?;
object_749.finish();
}
if let Some(var_750) = &input.aws_elastic_beanstalk_environment {
#[allow(unused_mut)]
let mut object_751 = object.key("AwsElasticBeanstalkEnvironment").start_object();
crate::json_ser::serialize_structure_crate_model_aws_elastic_beanstalk_environment_details(
&mut object_751,
var_750,
)?;
object_751.finish();
}
if let Some(var_752) = &input.aws_elasticsearch_domain {
#[allow(unused_mut)]
let mut object_753 = object.key("AwsElasticsearchDomain").start_object();
crate::json_ser::serialize_structure_crate_model_aws_elasticsearch_domain_details(
&mut object_753,
var_752,
)?;
object_753.finish();
}
if let Some(var_754) = &input.aws_s3_bucket {
#[allow(unused_mut)]
let mut object_755 = object.key("AwsS3Bucket").start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_details(
&mut object_755,
var_754,
)?;
object_755.finish();
}
if let Some(var_756) = &input.aws_s3_account_public_access_block {
#[allow(unused_mut)]
let mut object_757 = object.key("AwsS3AccountPublicAccessBlock").start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_account_public_access_block_details(&mut object_757, var_756)?;
object_757.finish();
}
if let Some(var_758) = &input.aws_s3_object {
#[allow(unused_mut)]
let mut object_759 = object.key("AwsS3Object").start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_object_details(
&mut object_759,
var_758,
)?;
object_759.finish();
}
if let Some(var_760) = &input.aws_secrets_manager_secret {
#[allow(unused_mut)]
let mut object_761 = object.key("AwsSecretsManagerSecret").start_object();
crate::json_ser::serialize_structure_crate_model_aws_secrets_manager_secret_details(
&mut object_761,
var_760,
)?;
object_761.finish();
}
if let Some(var_762) = &input.aws_iam_access_key {
#[allow(unused_mut)]
let mut object_763 = object.key("AwsIamAccessKey").start_object();
crate::json_ser::serialize_structure_crate_model_aws_iam_access_key_details(
&mut object_763,
var_762,
)?;
object_763.finish();
}
if let Some(var_764) = &input.aws_iam_user {
#[allow(unused_mut)]
let mut object_765 = object.key("AwsIamUser").start_object();
crate::json_ser::serialize_structure_crate_model_aws_iam_user_details(
&mut object_765,
var_764,
)?;
object_765.finish();
}
if let Some(var_766) = &input.aws_iam_policy {
#[allow(unused_mut)]
let mut object_767 = object.key("AwsIamPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_aws_iam_policy_details(
&mut object_767,
var_766,
)?;
object_767.finish();
}
if let Some(var_768) = &input.aws_api_gateway_v2_stage {
#[allow(unused_mut)]
let mut object_769 = object.key("AwsApiGatewayV2Stage").start_object();
crate::json_ser::serialize_structure_crate_model_aws_api_gateway_v2_stage_details(
&mut object_769,
var_768,
)?;
object_769.finish();
}
if let Some(var_770) = &input.aws_api_gateway_v2_api {
#[allow(unused_mut)]
let mut object_771 = object.key("AwsApiGatewayV2Api").start_object();
crate::json_ser::serialize_structure_crate_model_aws_api_gateway_v2_api_details(
&mut object_771,
var_770,
)?;
object_771.finish();
}
if let Some(var_772) = &input.aws_dynamo_db_table {
#[allow(unused_mut)]
let mut object_773 = object.key("AwsDynamoDbTable").start_object();
crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_details(
&mut object_773,
var_772,
)?;
object_773.finish();
}
if let Some(var_774) = &input.aws_api_gateway_stage {
#[allow(unused_mut)]
let mut object_775 = object.key("AwsApiGatewayStage").start_object();
crate::json_ser::serialize_structure_crate_model_aws_api_gateway_stage_details(
&mut object_775,
var_774,
)?;
object_775.finish();
}
if let Some(var_776) = &input.aws_api_gateway_rest_api {
#[allow(unused_mut)]
let mut object_777 = object.key("AwsApiGatewayRestApi").start_object();
crate::json_ser::serialize_structure_crate_model_aws_api_gateway_rest_api_details(
&mut object_777,
var_776,
)?;
object_777.finish();
}
if let Some(var_778) = &input.aws_cloud_trail_trail {
#[allow(unused_mut)]
let mut object_779 = object.key("AwsCloudTrailTrail").start_object();
crate::json_ser::serialize_structure_crate_model_aws_cloud_trail_trail_details(
&mut object_779,
var_778,
)?;
object_779.finish();
}
if let Some(var_780) = &input.aws_ssm_patch_compliance {
#[allow(unused_mut)]
let mut object_781 = object.key("AwsSsmPatchCompliance").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ssm_patch_compliance_details(
&mut object_781,
var_780,
)?;
object_781.finish();
}
if let Some(var_782) = &input.aws_certificate_manager_certificate {
#[allow(unused_mut)]
let mut object_783 = object
.key("AwsCertificateManagerCertificate")
.start_object();
crate::json_ser::serialize_structure_crate_model_aws_certificate_manager_certificate_details(&mut object_783, var_782)?;
object_783.finish();
}
if let Some(var_784) = &input.aws_redshift_cluster {
#[allow(unused_mut)]
let mut object_785 = object.key("AwsRedshiftCluster").start_object();
crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_details(
&mut object_785,
var_784,
)?;
object_785.finish();
}
if let Some(var_786) = &input.aws_elb_load_balancer {
#[allow(unused_mut)]
let mut object_787 = object.key("AwsElbLoadBalancer").start_object();
crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_details(
&mut object_787,
var_786,
)?;
object_787.finish();
}
if let Some(var_788) = &input.aws_iam_group {
#[allow(unused_mut)]
let mut object_789 = object.key("AwsIamGroup").start_object();
crate::json_ser::serialize_structure_crate_model_aws_iam_group_details(
&mut object_789,
var_788,
)?;
object_789.finish();
}
if let Some(var_790) = &input.aws_iam_role {
#[allow(unused_mut)]
let mut object_791 = object.key("AwsIamRole").start_object();
crate::json_ser::serialize_structure_crate_model_aws_iam_role_details(
&mut object_791,
var_790,
)?;
object_791.finish();
}
if let Some(var_792) = &input.aws_kms_key {
#[allow(unused_mut)]
let mut object_793 = object.key("AwsKmsKey").start_object();
crate::json_ser::serialize_structure_crate_model_aws_kms_key_details(
&mut object_793,
var_792,
)?;
object_793.finish();
}
if let Some(var_794) = &input.aws_lambda_function {
#[allow(unused_mut)]
let mut object_795 = object.key("AwsLambdaFunction").start_object();
crate::json_ser::serialize_structure_crate_model_aws_lambda_function_details(
&mut object_795,
var_794,
)?;
object_795.finish();
}
if let Some(var_796) = &input.aws_lambda_layer_version {
#[allow(unused_mut)]
let mut object_797 = object.key("AwsLambdaLayerVersion").start_object();
crate::json_ser::serialize_structure_crate_model_aws_lambda_layer_version_details(
&mut object_797,
var_796,
)?;
object_797.finish();
}
if let Some(var_798) = &input.aws_rds_db_instance {
#[allow(unused_mut)]
let mut object_799 = object.key("AwsRdsDbInstance").start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_instance_details(
&mut object_799,
var_798,
)?;
object_799.finish();
}
if let Some(var_800) = &input.aws_sns_topic {
#[allow(unused_mut)]
let mut object_801 = object.key("AwsSnsTopic").start_object();
crate::json_ser::serialize_structure_crate_model_aws_sns_topic_details(
&mut object_801,
var_800,
)?;
object_801.finish();
}
if let Some(var_802) = &input.aws_sqs_queue {
#[allow(unused_mut)]
let mut object_803 = object.key("AwsSqsQueue").start_object();
crate::json_ser::serialize_structure_crate_model_aws_sqs_queue_details(
&mut object_803,
var_802,
)?;
object_803.finish();
}
if let Some(var_804) = &input.aws_waf_web_acl {
#[allow(unused_mut)]
let mut object_805 = object.key("AwsWafWebAcl").start_object();
crate::json_ser::serialize_structure_crate_model_aws_waf_web_acl_details(
&mut object_805,
var_804,
)?;
object_805.finish();
}
if let Some(var_806) = &input.aws_rds_db_snapshot {
#[allow(unused_mut)]
let mut object_807 = object.key("AwsRdsDbSnapshot").start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_snapshot_details(
&mut object_807,
var_806,
)?;
object_807.finish();
}
if let Some(var_808) = &input.aws_rds_db_cluster_snapshot {
#[allow(unused_mut)]
let mut object_809 = object.key("AwsRdsDbClusterSnapshot").start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_cluster_snapshot_details(
&mut object_809,
var_808,
)?;
object_809.finish();
}
if let Some(var_810) = &input.aws_rds_db_cluster {
#[allow(unused_mut)]
let mut object_811 = object.key("AwsRdsDbCluster").start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_cluster_details(
&mut object_811,
var_810,
)?;
object_811.finish();
}
if let Some(var_812) = &input.aws_ecs_cluster {
#[allow(unused_mut)]
let mut object_813 = object.key("AwsEcsCluster").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_cluster_details(
&mut object_813,
var_812,
)?;
object_813.finish();
}
if let Some(var_814) = &input.aws_ecs_container {
#[allow(unused_mut)]
let mut object_815 = object.key("AwsEcsContainer").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_container_details(
&mut object_815,
var_814,
)?;
object_815.finish();
}
if let Some(var_816) = &input.aws_ecs_task_definition {
#[allow(unused_mut)]
let mut object_817 = object.key("AwsEcsTaskDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_details(
&mut object_817,
var_816,
)?;
object_817.finish();
}
if let Some(var_818) = &input.container {
#[allow(unused_mut)]
let mut object_819 = object.key("Container").start_object();
crate::json_ser::serialize_structure_crate_model_container_details(
&mut object_819,
var_818,
)?;
object_819.finish();
}
if let Some(var_820) = &input.other {
#[allow(unused_mut)]
let mut object_821 = object.key("Other").start_object();
for (key_822, value_823) in var_820 {
{
object_821.key(key_822.as_str()).string(value_823.as_str());
}
}
object_821.finish();
}
if let Some(var_824) = &input.aws_rds_event_subscription {
#[allow(unused_mut)]
let mut object_825 = object.key("AwsRdsEventSubscription").start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_event_subscription_details(
&mut object_825,
var_824,
)?;
object_825.finish();
}
if let Some(var_826) = &input.aws_ecs_service {
#[allow(unused_mut)]
let mut object_827 = object.key("AwsEcsService").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_service_details(
&mut object_827,
var_826,
)?;
object_827.finish();
}
if let Some(var_828) = &input.aws_auto_scaling_launch_configuration {
#[allow(unused_mut)]
let mut object_829 = object
.key("AwsAutoScalingLaunchConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_aws_auto_scaling_launch_configuration_details(&mut object_829, var_828)?;
object_829.finish();
}
if let Some(var_830) = &input.aws_ec2_vpn_connection {
#[allow(unused_mut)]
let mut object_831 = object.key("AwsEc2VpnConnection").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_vpn_connection_details(
&mut object_831,
var_830,
)?;
object_831.finish();
}
if let Some(var_832) = &input.aws_ecr_container_image {
#[allow(unused_mut)]
let mut object_833 = object.key("AwsEcrContainerImage").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecr_container_image_details(
&mut object_833,
var_832,
)?;
object_833.finish();
}
if let Some(var_834) = &input.aws_open_search_service_domain {
#[allow(unused_mut)]
let mut object_835 = object.key("AwsOpenSearchServiceDomain").start_object();
crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_details(
&mut object_835,
var_834,
)?;
object_835.finish();
}
if let Some(var_836) = &input.aws_ec2_vpc_endpoint_service {
#[allow(unused_mut)]
let mut object_837 = object.key("AwsEc2VpcEndpointService").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_vpc_endpoint_service_details(
&mut object_837,
var_836,
)?;
object_837.finish();
}
if let Some(var_838) = &input.aws_xray_encryption_config {
#[allow(unused_mut)]
let mut object_839 = object.key("AwsXrayEncryptionConfig").start_object();
crate::json_ser::serialize_structure_crate_model_aws_xray_encryption_config_details(
&mut object_839,
var_838,
)?;
object_839.finish();
}
if let Some(var_840) = &input.aws_waf_rate_based_rule {
#[allow(unused_mut)]
let mut object_841 = object.key("AwsWafRateBasedRule").start_object();
crate::json_ser::serialize_structure_crate_model_aws_waf_rate_based_rule_details(
&mut object_841,
var_840,
)?;
object_841.finish();
}
if let Some(var_842) = &input.aws_waf_regional_rate_based_rule {
#[allow(unused_mut)]
let mut object_843 = object.key("AwsWafRegionalRateBasedRule").start_object();
crate::json_ser::serialize_structure_crate_model_aws_waf_regional_rate_based_rule_details(
&mut object_843,
var_842,
)?;
object_843.finish();
}
if let Some(var_844) = &input.aws_ecr_repository {
#[allow(unused_mut)]
let mut object_845 = object.key("AwsEcrRepository").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecr_repository_details(
&mut object_845,
var_844,
)?;
object_845.finish();
}
if let Some(var_846) = &input.aws_eks_cluster {
#[allow(unused_mut)]
let mut object_847 = object.key("AwsEksCluster").start_object();
crate::json_ser::serialize_structure_crate_model_aws_eks_cluster_details(
&mut object_847,
var_846,
)?;
object_847.finish();
}
if let Some(var_848) = &input.aws_network_firewall_firewall_policy {
#[allow(unused_mut)]
let mut object_849 = object
.key("AwsNetworkFirewallFirewallPolicy")
.start_object();
crate::json_ser::serialize_structure_crate_model_aws_network_firewall_firewall_policy_details(&mut object_849, var_848)?;
object_849.finish();
}
if let Some(var_850) = &input.aws_network_firewall_firewall {
#[allow(unused_mut)]
let mut object_851 = object.key("AwsNetworkFirewallFirewall").start_object();
crate::json_ser::serialize_structure_crate_model_aws_network_firewall_firewall_details(
&mut object_851,
var_850,
)?;
object_851.finish();
}
if let Some(var_852) = &input.aws_network_firewall_rule_group {
#[allow(unused_mut)]
let mut object_853 = object.key("AwsNetworkFirewallRuleGroup").start_object();
crate::json_ser::serialize_structure_crate_model_aws_network_firewall_rule_group_details(
&mut object_853,
var_852,
)?;
object_853.finish();
}
if let Some(var_854) = &input.aws_rds_db_security_group {
#[allow(unused_mut)]
let mut object_855 = object.key("AwsRdsDbSecurityGroup").start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_security_group_details(
&mut object_855,
var_854,
)?;
object_855.finish();
}
if let Some(var_856) = &input.aws_kinesis_stream {
#[allow(unused_mut)]
let mut object_857 = object.key("AwsKinesisStream").start_object();
crate::json_ser::serialize_structure_crate_model_aws_kinesis_stream_details(
&mut object_857,
var_856,
)?;
object_857.finish();
}
if let Some(var_858) = &input.aws_ec2_transit_gateway {
#[allow(unused_mut)]
let mut object_859 = object.key("AwsEc2TransitGateway").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_transit_gateway_details(
&mut object_859,
var_858,
)?;
object_859.finish();
}
if let Some(var_860) = &input.aws_efs_access_point {
#[allow(unused_mut)]
let mut object_861 = object.key("AwsEfsAccessPoint").start_object();
crate::json_ser::serialize_structure_crate_model_aws_efs_access_point_details(
&mut object_861,
var_860,
)?;
object_861.finish();
}
if let Some(var_862) = &input.aws_cloud_formation_stack {
#[allow(unused_mut)]
let mut object_863 = object.key("AwsCloudFormationStack").start_object();
crate::json_ser::serialize_structure_crate_model_aws_cloud_formation_stack_details(
&mut object_863,
var_862,
)?;
object_863.finish();
}
if let Some(var_864) = &input.aws_cloud_watch_alarm {
#[allow(unused_mut)]
let mut object_865 = object.key("AwsCloudWatchAlarm").start_object();
crate::json_ser::serialize_structure_crate_model_aws_cloud_watch_alarm_details(
&mut object_865,
var_864,
)?;
object_865.finish();
}
if let Some(var_866) = &input.aws_ec2_vpc_peering_connection {
#[allow(unused_mut)]
let mut object_867 = object.key("AwsEc2VpcPeeringConnection").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_vpc_peering_connection_details(
&mut object_867,
var_866,
)?;
object_867.finish();
}
if let Some(var_868) = &input.aws_waf_regional_rule_group {
#[allow(unused_mut)]
let mut object_869 = object.key("AwsWafRegionalRuleGroup").start_object();
crate::json_ser::serialize_structure_crate_model_aws_waf_regional_rule_group_details(
&mut object_869,
var_868,
)?;
object_869.finish();
}
if let Some(var_870) = &input.aws_waf_regional_rule {
#[allow(unused_mut)]
let mut object_871 = object.key("AwsWafRegionalRule").start_object();
crate::json_ser::serialize_structure_crate_model_aws_waf_regional_rule_details(
&mut object_871,
var_870,
)?;
object_871.finish();
}
if let Some(var_872) = &input.aws_waf_regional_web_acl {
#[allow(unused_mut)]
let mut object_873 = object.key("AwsWafRegionalWebAcl").start_object();
crate::json_ser::serialize_structure_crate_model_aws_waf_regional_web_acl_details(
&mut object_873,
var_872,
)?;
object_873.finish();
}
if let Some(var_874) = &input.aws_waf_rule {
#[allow(unused_mut)]
let mut object_875 = object.key("AwsWafRule").start_object();
crate::json_ser::serialize_structure_crate_model_aws_waf_rule_details(
&mut object_875,
var_874,
)?;
object_875.finish();
}
if let Some(var_876) = &input.aws_waf_rule_group {
#[allow(unused_mut)]
let mut object_877 = object.key("AwsWafRuleGroup").start_object();
crate::json_ser::serialize_structure_crate_model_aws_waf_rule_group_details(
&mut object_877,
var_876,
)?;
object_877.finish();
}
if let Some(var_878) = &input.aws_ecs_task {
#[allow(unused_mut)]
let mut object_879 = object.key("AwsEcsTask").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_details(
&mut object_879,
var_878,
)?;
object_879.finish();
}
if let Some(var_880) = &input.aws_backup_backup_vault {
#[allow(unused_mut)]
let mut object_881 = object.key("AwsBackupBackupVault").start_object();
crate::json_ser::serialize_structure_crate_model_aws_backup_backup_vault_details(
&mut object_881,
var_880,
)?;
object_881.finish();
}
if let Some(var_882) = &input.aws_backup_backup_plan {
#[allow(unused_mut)]
let mut object_883 = object.key("AwsBackupBackupPlan").start_object();
crate::json_ser::serialize_structure_crate_model_aws_backup_backup_plan_details(
&mut object_883,
var_882,
)?;
object_883.finish();
}
if let Some(var_884) = &input.aws_backup_recovery_point {
#[allow(unused_mut)]
let mut object_885 = object.key("AwsBackupRecoveryPoint").start_object();
crate::json_ser::serialize_structure_crate_model_aws_backup_recovery_point_details(
&mut object_885,
var_884,
)?;
object_885.finish();
}
if let Some(var_886) = &input.aws_ec2_launch_template {
#[allow(unused_mut)]
let mut object_887 = object.key("AwsEc2LaunchTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_details(
&mut object_887,
var_886,
)?;
object_887.finish();
}
if let Some(var_888) = &input.aws_sage_maker_notebook_instance {
#[allow(unused_mut)]
let mut object_889 = object.key("AwsSageMakerNotebookInstance").start_object();
crate::json_ser::serialize_structure_crate_model_aws_sage_maker_notebook_instance_details(
&mut object_889,
var_888,
)?;
object_889.finish();
}
if let Some(var_890) = &input.aws_wafv2_web_acl {
#[allow(unused_mut)]
let mut object_891 = object.key("AwsWafv2WebAcl").start_object();
crate::json_ser::serialize_structure_crate_model_aws_wafv2_web_acl_details(
&mut object_891,
var_890,
)?;
object_891.finish();
}
if let Some(var_892) = &input.aws_wafv2_rule_group {
#[allow(unused_mut)]
let mut object_893 = object.key("AwsWafv2RuleGroup").start_object();
crate::json_ser::serialize_structure_crate_model_aws_wafv2_rule_group_details(
&mut object_893,
var_892,
)?;
object_893.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_status_reason(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StatusReason,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_894) = &input.reason_code {
object.key("ReasonCode").string(var_894.as_str());
}
if let Some(var_895) = &input.description {
object.key("Description").string(var_895.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_software_package(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SoftwarePackage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_896) = &input.name {
object.key("Name").string(var_896.as_str());
}
if let Some(var_897) = &input.version {
object.key("Version").string(var_897.as_str());
}
if let Some(var_898) = &input.epoch {
object.key("Epoch").string(var_898.as_str());
}
if let Some(var_899) = &input.release {
object.key("Release").string(var_899.as_str());
}
if let Some(var_900) = &input.architecture {
object.key("Architecture").string(var_900.as_str());
}
if let Some(var_901) = &input.package_manager {
object.key("PackageManager").string(var_901.as_str());
}
if let Some(var_902) = &input.file_path {
object.key("FilePath").string(var_902.as_str());
}
if let Some(var_903) = &input.fixed_in_version {
object.key("FixedInVersion").string(var_903.as_str());
}
if let Some(var_904) = &input.remediation {
object.key("Remediation").string(var_904.as_str());
}
if let Some(var_905) = &input.source_layer_hash {
object.key("SourceLayerHash").string(var_905.as_str());
}
if let Some(var_906) = &input.source_layer_arn {
object.key("SourceLayerArn").string(var_906.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_cvss(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Cvss,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_907) = &input.version {
object.key("Version").string(var_907.as_str());
}
if input.base_score != 0.0 {
object.key("BaseScore").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.base_score).into()),
);
}
if let Some(var_908) = &input.base_vector {
object.key("BaseVector").string(var_908.as_str());
}
if let Some(var_909) = &input.source {
object.key("Source").string(var_909.as_str());
}
if let Some(var_910) = &input.adjustments {
let mut array_911 = object.key("Adjustments").start_array();
for item_912 in var_910 {
{
#[allow(unused_mut)]
let mut object_913 = array_911.value().start_object();
crate::json_ser::serialize_structure_crate_model_adjustment(
&mut object_913,
item_912,
)?;
object_913.finish();
}
}
array_911.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_vulnerability_vendor(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VulnerabilityVendor,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_914) = &input.name {
object.key("Name").string(var_914.as_str());
}
if let Some(var_915) = &input.url {
object.key("Url").string(var_915.as_str());
}
if let Some(var_916) = &input.vendor_severity {
object.key("VendorSeverity").string(var_916.as_str());
}
if let Some(var_917) = &input.vendor_created_at {
object.key("VendorCreatedAt").string(var_917.as_str());
}
if let Some(var_918) = &input.vendor_updated_at {
object.key("VendorUpdatedAt").string(var_918.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_network_connection_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NetworkConnectionAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_919) = &input.connection_direction {
object.key("ConnectionDirection").string(var_919.as_str());
}
if let Some(var_920) = &input.remote_ip_details {
#[allow(unused_mut)]
let mut object_921 = object.key("RemoteIpDetails").start_object();
crate::json_ser::serialize_structure_crate_model_action_remote_ip_details(
&mut object_921,
var_920,
)?;
object_921.finish();
}
if let Some(var_922) = &input.remote_port_details {
#[allow(unused_mut)]
let mut object_923 = object.key("RemotePortDetails").start_object();
crate::json_ser::serialize_structure_crate_model_action_remote_port_details(
&mut object_923,
var_922,
)?;
object_923.finish();
}
if let Some(var_924) = &input.local_port_details {
#[allow(unused_mut)]
let mut object_925 = object.key("LocalPortDetails").start_object();
crate::json_ser::serialize_structure_crate_model_action_local_port_details(
&mut object_925,
var_924,
)?;
object_925.finish();
}
if let Some(var_926) = &input.protocol {
object.key("Protocol").string(var_926.as_str());
}
if input.blocked {
object.key("Blocked").boolean(input.blocked);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_api_call_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsApiCallAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_927) = &input.api {
object.key("Api").string(var_927.as_str());
}
if let Some(var_928) = &input.service_name {
object.key("ServiceName").string(var_928.as_str());
}
if let Some(var_929) = &input.caller_type {
object.key("CallerType").string(var_929.as_str());
}
if let Some(var_930) = &input.remote_ip_details {
#[allow(unused_mut)]
let mut object_931 = object.key("RemoteIpDetails").start_object();
crate::json_ser::serialize_structure_crate_model_action_remote_ip_details(
&mut object_931,
var_930,
)?;
object_931.finish();
}
if let Some(var_932) = &input.domain_details {
#[allow(unused_mut)]
let mut object_933 = object.key("DomainDetails").start_object();
crate::json_ser::serialize_structure_crate_model_aws_api_call_action_domain_details(
&mut object_933,
var_932,
)?;
object_933.finish();
}
if let Some(var_934) = &input.affected_resources {
#[allow(unused_mut)]
let mut object_935 = object.key("AffectedResources").start_object();
for (key_936, value_937) in var_934 {
{
object_935.key(key_936.as_str()).string(value_937.as_str());
}
}
object_935.finish();
}
if let Some(var_938) = &input.first_seen {
object.key("FirstSeen").string(var_938.as_str());
}
if let Some(var_939) = &input.last_seen {
object.key("LastSeen").string(var_939.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_dns_request_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DnsRequestAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_940) = &input.domain {
object.key("Domain").string(var_940.as_str());
}
if let Some(var_941) = &input.protocol {
object.key("Protocol").string(var_941.as_str());
}
if input.blocked {
object.key("Blocked").boolean(input.blocked);
}
Ok(())
}
pub fn serialize_structure_crate_model_port_probe_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PortProbeAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_942) = &input.port_probe_details {
let mut array_943 = object.key("PortProbeDetails").start_array();
for item_944 in var_942 {
{
#[allow(unused_mut)]
let mut object_945 = array_943.value().start_object();
crate::json_ser::serialize_structure_crate_model_port_probe_detail(
&mut object_945,
item_944,
)?;
object_945.finish();
}
}
array_943.finish();
}
if input.blocked {
object.key("Blocked").boolean(input.blocked);
}
Ok(())
}
pub fn serialize_structure_crate_model_finding_provider_severity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FindingProviderSeverity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_946) = &input.label {
object.key("Label").string(var_946.as_str());
}
if let Some(var_947) = &input.original {
object.key("Original").string(var_947.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_date_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DateRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.value != 0 {
object.key("Value").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.value).into()),
);
}
if let Some(var_948) = &input.unit {
object.key("Unit").string(var_948.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_network_path_component_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NetworkPathComponentDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_949) = &input.address {
let mut array_950 = object.key("Address").start_array();
for item_951 in var_949 {
{
array_950.value().string(item_951.as_str());
}
}
array_950.finish();
}
if let Some(var_952) = &input.port_ranges {
let mut array_953 = object.key("PortRanges").start_array();
for item_954 in var_952 {
{
#[allow(unused_mut)]
let mut object_955 = array_953.value().start_object();
crate::json_ser::serialize_structure_crate_model_port_range(
&mut object_955,
item_954,
)?;
object_955.finish();
}
}
array_953.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_classification_result(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ClassificationResult,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_956) = &input.mime_type {
object.key("MimeType").string(var_956.as_str());
}
if input.size_classified != 0 {
object.key("SizeClassified").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.size_classified).into()),
);
}
if input.additional_occurrences {
object
.key("AdditionalOccurrences")
.boolean(input.additional_occurrences);
}
if let Some(var_957) = &input.status {
#[allow(unused_mut)]
let mut object_958 = object.key("Status").start_object();
crate::json_ser::serialize_structure_crate_model_classification_status(
&mut object_958,
var_957,
)?;
object_958.finish();
}
if let Some(var_959) = &input.sensitive_data {
let mut array_960 = object.key("SensitiveData").start_array();
for item_961 in var_959 {
{
#[allow(unused_mut)]
let mut object_962 = array_960.value().start_object();
crate::json_ser::serialize_structure_crate_model_sensitive_data_result(
&mut object_962,
item_961,
)?;
object_962.finish();
}
}
array_960.finish();
}
if let Some(var_963) = &input.custom_data_identifiers {
#[allow(unused_mut)]
let mut object_964 = object.key("CustomDataIdentifiers").start_object();
crate::json_ser::serialize_structure_crate_model_custom_data_identifiers_result(
&mut object_964,
var_963,
)?;
object_964.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_auto_scaling_auto_scaling_group_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsAutoScalingAutoScalingGroupDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_965) = &input.launch_configuration_name {
object
.key("LaunchConfigurationName")
.string(var_965.as_str());
}
if let Some(var_966) = &input.load_balancer_names {
let mut array_967 = object.key("LoadBalancerNames").start_array();
for item_968 in var_966 {
{
array_967.value().string(item_968.as_str());
}
}
array_967.finish();
}
if let Some(var_969) = &input.health_check_type {
object.key("HealthCheckType").string(var_969.as_str());
}
if input.health_check_grace_period != 0 {
object.key("HealthCheckGracePeriod").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.health_check_grace_period).into()),
);
}
if let Some(var_970) = &input.created_time {
object.key("CreatedTime").string(var_970.as_str());
}
if let Some(var_971) = &input.mixed_instances_policy {
#[allow(unused_mut)]
let mut object_972 = object.key("MixedInstancesPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_aws_auto_scaling_auto_scaling_group_mixed_instances_policy_details(&mut object_972, var_971)?;
object_972.finish();
}
if let Some(var_973) = &input.availability_zones {
let mut array_974 = object.key("AvailabilityZones").start_array();
for item_975 in var_973 {
{
#[allow(unused_mut)]
let mut object_976 = array_974.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_auto_scaling_auto_scaling_group_availability_zones_list_details(&mut object_976, item_975)?;
object_976.finish();
}
}
array_974.finish();
}
if let Some(var_977) = &input.launch_template {
#[allow(unused_mut)]
let mut object_978 = object.key("LaunchTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_aws_auto_scaling_auto_scaling_group_launch_template_launch_template_specification(&mut object_978, var_977)?;
object_978.finish();
}
if input.capacity_rebalance {
object
.key("CapacityRebalance")
.boolean(input.capacity_rebalance);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_code_build_project_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCodeBuildProjectDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_979) = &input.encryption_key {
object.key("EncryptionKey").string(var_979.as_str());
}
if let Some(var_980) = &input.artifacts {
let mut array_981 = object.key("Artifacts").start_array();
for item_982 in var_980 {
{
#[allow(unused_mut)]
let mut object_983 = array_981.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_code_build_project_artifacts_details(&mut object_983, item_982)?;
object_983.finish();
}
}
array_981.finish();
}
if let Some(var_984) = &input.environment {
#[allow(unused_mut)]
let mut object_985 = object.key("Environment").start_object();
crate::json_ser::serialize_structure_crate_model_aws_code_build_project_environment(
&mut object_985,
var_984,
)?;
object_985.finish();
}
if let Some(var_986) = &input.name {
object.key("Name").string(var_986.as_str());
}
if let Some(var_987) = &input.source {
#[allow(unused_mut)]
let mut object_988 = object.key("Source").start_object();
crate::json_ser::serialize_structure_crate_model_aws_code_build_project_source(
&mut object_988,
var_987,
)?;
object_988.finish();
}
if let Some(var_989) = &input.service_role {
object.key("ServiceRole").string(var_989.as_str());
}
if let Some(var_990) = &input.logs_config {
#[allow(unused_mut)]
let mut object_991 = object.key("LogsConfig").start_object();
crate::json_ser::serialize_structure_crate_model_aws_code_build_project_logs_config_details(&mut object_991, var_990)?;
object_991.finish();
}
if let Some(var_992) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_993 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_aws_code_build_project_vpc_config(
&mut object_993,
var_992,
)?;
object_993.finish();
}
if let Some(var_994) = &input.secondary_artifacts {
let mut array_995 = object.key("SecondaryArtifacts").start_array();
for item_996 in var_994 {
{
#[allow(unused_mut)]
let mut object_997 = array_995.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_code_build_project_artifacts_details(&mut object_997, item_996)?;
object_997.finish();
}
}
array_995.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_cloud_front_distribution_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCloudFrontDistributionDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_998) = &input.cache_behaviors {
#[allow(unused_mut)]
let mut object_999 = object.key("CacheBehaviors").start_object();
crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_cache_behaviors(&mut object_999, var_998)?;
object_999.finish();
}
if let Some(var_1000) = &input.default_cache_behavior {
#[allow(unused_mut)]
let mut object_1001 = object.key("DefaultCacheBehavior").start_object();
crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_default_cache_behavior(&mut object_1001, var_1000)?;
object_1001.finish();
}
if let Some(var_1002) = &input.default_root_object {
object.key("DefaultRootObject").string(var_1002.as_str());
}
if let Some(var_1003) = &input.domain_name {
object.key("DomainName").string(var_1003.as_str());
}
if let Some(var_1004) = &input.e_tag {
object.key("ETag").string(var_1004.as_str());
}
if let Some(var_1005) = &input.last_modified_time {
object.key("LastModifiedTime").string(var_1005.as_str());
}
if let Some(var_1006) = &input.logging {
#[allow(unused_mut)]
let mut object_1007 = object.key("Logging").start_object();
crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_logging(
&mut object_1007,
var_1006,
)?;
object_1007.finish();
}
if let Some(var_1008) = &input.origins {
#[allow(unused_mut)]
let mut object_1009 = object.key("Origins").start_object();
crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_origins(
&mut object_1009,
var_1008,
)?;
object_1009.finish();
}
if let Some(var_1010) = &input.origin_groups {
#[allow(unused_mut)]
let mut object_1011 = object.key("OriginGroups").start_object();
crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_origin_groups(&mut object_1011, var_1010)?;
object_1011.finish();
}
if let Some(var_1012) = &input.viewer_certificate {
#[allow(unused_mut)]
let mut object_1013 = object.key("ViewerCertificate").start_object();
crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_viewer_certificate(&mut object_1013, var_1012)?;
object_1013.finish();
}
if let Some(var_1014) = &input.status {
object.key("Status").string(var_1014.as_str());
}
if let Some(var_1015) = &input.web_acl_id {
object.key("WebAclId").string(var_1015.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_instance_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2InstanceDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1016) = &input.r#type {
object.key("Type").string(var_1016.as_str());
}
if let Some(var_1017) = &input.image_id {
object.key("ImageId").string(var_1017.as_str());
}
if let Some(var_1018) = &input.ip_v4_addresses {
let mut array_1019 = object.key("IpV4Addresses").start_array();
for item_1020 in var_1018 {
{
array_1019.value().string(item_1020.as_str());
}
}
array_1019.finish();
}
if let Some(var_1021) = &input.ip_v6_addresses {
let mut array_1022 = object.key("IpV6Addresses").start_array();
for item_1023 in var_1021 {
{
array_1022.value().string(item_1023.as_str());
}
}
array_1022.finish();
}
if let Some(var_1024) = &input.key_name {
object.key("KeyName").string(var_1024.as_str());
}
if let Some(var_1025) = &input.iam_instance_profile_arn {
object
.key("IamInstanceProfileArn")
.string(var_1025.as_str());
}
if let Some(var_1026) = &input.vpc_id {
object.key("VpcId").string(var_1026.as_str());
}
if let Some(var_1027) = &input.subnet_id {
object.key("SubnetId").string(var_1027.as_str());
}
if let Some(var_1028) = &input.launched_at {
object.key("LaunchedAt").string(var_1028.as_str());
}
if let Some(var_1029) = &input.network_interfaces {
let mut array_1030 = object.key("NetworkInterfaces").start_array();
for item_1031 in var_1029 {
{
#[allow(unused_mut)]
let mut object_1032 = array_1030.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_instance_network_interfaces_details(&mut object_1032, item_1031)?;
object_1032.finish();
}
}
array_1030.finish();
}
if let Some(var_1033) = &input.virtualization_type {
object.key("VirtualizationType").string(var_1033.as_str());
}
if let Some(var_1034) = &input.metadata_options {
#[allow(unused_mut)]
let mut object_1035 = object.key("MetadataOptions").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_instance_metadata_options(
&mut object_1035,
var_1034,
)?;
object_1035.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_network_interface_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2NetworkInterfaceDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1036) = &input.attachment {
#[allow(unused_mut)]
let mut object_1037 = object.key("Attachment").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_network_interface_attachment(
&mut object_1037,
var_1036,
)?;
object_1037.finish();
}
if let Some(var_1038) = &input.network_interface_id {
object.key("NetworkInterfaceId").string(var_1038.as_str());
}
if let Some(var_1039) = &input.security_groups {
let mut array_1040 = object.key("SecurityGroups").start_array();
for item_1041 in var_1039 {
{
#[allow(unused_mut)]
let mut object_1042 = array_1040.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_network_interface_security_group(&mut object_1042, item_1041)?;
object_1042.finish();
}
}
array_1040.finish();
}
if input.source_dest_check {
object
.key("SourceDestCheck")
.boolean(input.source_dest_check);
}
if let Some(var_1043) = &input.ip_v6_addresses {
let mut array_1044 = object.key("IpV6Addresses").start_array();
for item_1045 in var_1043 {
{
#[allow(unused_mut)]
let mut object_1046 = array_1044.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_network_interface_ip_v6_address_detail(&mut object_1046, item_1045)?;
object_1046.finish();
}
}
array_1044.finish();
}
if let Some(var_1047) = &input.private_ip_addresses {
let mut array_1048 = object.key("PrivateIpAddresses").start_array();
for item_1049 in var_1047 {
{
#[allow(unused_mut)]
let mut object_1050 = array_1048.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_network_interface_private_ip_address_detail(&mut object_1050, item_1049)?;
object_1050.finish();
}
}
array_1048.finish();
}
if let Some(var_1051) = &input.public_dns_name {
object.key("PublicDnsName").string(var_1051.as_str());
}
if let Some(var_1052) = &input.public_ip {
object.key("PublicIp").string(var_1052.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_security_group_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2SecurityGroupDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1053) = &input.group_name {
object.key("GroupName").string(var_1053.as_str());
}
if let Some(var_1054) = &input.group_id {
object.key("GroupId").string(var_1054.as_str());
}
if let Some(var_1055) = &input.owner_id {
object.key("OwnerId").string(var_1055.as_str());
}
if let Some(var_1056) = &input.vpc_id {
object.key("VpcId").string(var_1056.as_str());
}
if let Some(var_1057) = &input.ip_permissions {
let mut array_1058 = object.key("IpPermissions").start_array();
for item_1059 in var_1057 {
{
#[allow(unused_mut)]
let mut object_1060 = array_1058.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_security_group_ip_permission(&mut object_1060, item_1059)?;
object_1060.finish();
}
}
array_1058.finish();
}
if let Some(var_1061) = &input.ip_permissions_egress {
let mut array_1062 = object.key("IpPermissionsEgress").start_array();
for item_1063 in var_1061 {
{
#[allow(unused_mut)]
let mut object_1064 = array_1062.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_security_group_ip_permission(&mut object_1064, item_1063)?;
object_1064.finish();
}
}
array_1062.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_volume_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2VolumeDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1065) = &input.create_time {
object.key("CreateTime").string(var_1065.as_str());
}
if let Some(var_1066) = &input.device_name {
object.key("DeviceName").string(var_1066.as_str());
}
if input.encrypted {
object.key("Encrypted").boolean(input.encrypted);
}
if input.size != 0 {
object.key("Size").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.size).into()),
);
}
if let Some(var_1067) = &input.snapshot_id {
object.key("SnapshotId").string(var_1067.as_str());
}
if let Some(var_1068) = &input.status {
object.key("Status").string(var_1068.as_str());
}
if let Some(var_1069) = &input.kms_key_id {
object.key("KmsKeyId").string(var_1069.as_str());
}
if let Some(var_1070) = &input.attachments {
let mut array_1071 = object.key("Attachments").start_array();
for item_1072 in var_1070 {
{
#[allow(unused_mut)]
let mut object_1073 = array_1071.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_volume_attachment(
&mut object_1073,
item_1072,
)?;
object_1073.finish();
}
}
array_1071.finish();
}
if let Some(var_1074) = &input.volume_id {
object.key("VolumeId").string(var_1074.as_str());
}
if let Some(var_1075) = &input.volume_type {
object.key("VolumeType").string(var_1075.as_str());
}
if let Some(var_1076) = &input.volume_scan_status {
object.key("VolumeScanStatus").string(var_1076.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_vpc_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2VpcDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1077) = &input.cidr_block_association_set {
let mut array_1078 = object.key("CidrBlockAssociationSet").start_array();
for item_1079 in var_1077 {
{
#[allow(unused_mut)]
let mut object_1080 = array_1078.value().start_object();
crate::json_ser::serialize_structure_crate_model_cidr_block_association(
&mut object_1080,
item_1079,
)?;
object_1080.finish();
}
}
array_1078.finish();
}
if let Some(var_1081) = &input.ipv6_cidr_block_association_set {
let mut array_1082 = object.key("Ipv6CidrBlockAssociationSet").start_array();
for item_1083 in var_1081 {
{
#[allow(unused_mut)]
let mut object_1084 = array_1082.value().start_object();
crate::json_ser::serialize_structure_crate_model_ipv6_cidr_block_association(
&mut object_1084,
item_1083,
)?;
object_1084.finish();
}
}
array_1082.finish();
}
if let Some(var_1085) = &input.dhcp_options_id {
object.key("DhcpOptionsId").string(var_1085.as_str());
}
if let Some(var_1086) = &input.state {
object.key("State").string(var_1086.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_eip_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2EipDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1087) = &input.instance_id {
object.key("InstanceId").string(var_1087.as_str());
}
if let Some(var_1088) = &input.public_ip {
object.key("PublicIp").string(var_1088.as_str());
}
if let Some(var_1089) = &input.allocation_id {
object.key("AllocationId").string(var_1089.as_str());
}
if let Some(var_1090) = &input.association_id {
object.key("AssociationId").string(var_1090.as_str());
}
if let Some(var_1091) = &input.domain {
object.key("Domain").string(var_1091.as_str());
}
if let Some(var_1092) = &input.public_ipv4_pool {
object.key("PublicIpv4Pool").string(var_1092.as_str());
}
if let Some(var_1093) = &input.network_border_group {
object.key("NetworkBorderGroup").string(var_1093.as_str());
}
if let Some(var_1094) = &input.network_interface_id {
object.key("NetworkInterfaceId").string(var_1094.as_str());
}
if let Some(var_1095) = &input.network_interface_owner_id {
object
.key("NetworkInterfaceOwnerId")
.string(var_1095.as_str());
}
if let Some(var_1096) = &input.private_ip_address {
object.key("PrivateIpAddress").string(var_1096.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_subnet_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2SubnetDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.assign_ipv6_address_on_creation {
object
.key("AssignIpv6AddressOnCreation")
.boolean(input.assign_ipv6_address_on_creation);
}
if let Some(var_1097) = &input.availability_zone {
object.key("AvailabilityZone").string(var_1097.as_str());
}
if let Some(var_1098) = &input.availability_zone_id {
object.key("AvailabilityZoneId").string(var_1098.as_str());
}
if input.available_ip_address_count != 0 {
object.key("AvailableIpAddressCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.available_ip_address_count).into()),
);
}
if let Some(var_1099) = &input.cidr_block {
object.key("CidrBlock").string(var_1099.as_str());
}
if input.default_for_az {
object.key("DefaultForAz").boolean(input.default_for_az);
}
if input.map_public_ip_on_launch {
object
.key("MapPublicIpOnLaunch")
.boolean(input.map_public_ip_on_launch);
}
if let Some(var_1100) = &input.owner_id {
object.key("OwnerId").string(var_1100.as_str());
}
if let Some(var_1101) = &input.state {
object.key("State").string(var_1101.as_str());
}
if let Some(var_1102) = &input.subnet_arn {
object.key("SubnetArn").string(var_1102.as_str());
}
if let Some(var_1103) = &input.subnet_id {
object.key("SubnetId").string(var_1103.as_str());
}
if let Some(var_1104) = &input.vpc_id {
object.key("VpcId").string(var_1104.as_str());
}
if let Some(var_1105) = &input.ipv6_cidr_block_association_set {
let mut array_1106 = object.key("Ipv6CidrBlockAssociationSet").start_array();
for item_1107 in var_1105 {
{
#[allow(unused_mut)]
let mut object_1108 = array_1106.value().start_object();
crate::json_ser::serialize_structure_crate_model_ipv6_cidr_block_association(
&mut object_1108,
item_1107,
)?;
object_1108.finish();
}
}
array_1106.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_network_acl_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2NetworkAclDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.is_default {
object.key("IsDefault").boolean(input.is_default);
}
if let Some(var_1109) = &input.network_acl_id {
object.key("NetworkAclId").string(var_1109.as_str());
}
if let Some(var_1110) = &input.owner_id {
object.key("OwnerId").string(var_1110.as_str());
}
if let Some(var_1111) = &input.vpc_id {
object.key("VpcId").string(var_1111.as_str());
}
if let Some(var_1112) = &input.associations {
let mut array_1113 = object.key("Associations").start_array();
for item_1114 in var_1112 {
{
#[allow(unused_mut)]
let mut object_1115 = array_1113.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_network_acl_association(
&mut object_1115,
item_1114,
)?;
object_1115.finish();
}
}
array_1113.finish();
}
if let Some(var_1116) = &input.entries {
let mut array_1117 = object.key("Entries").start_array();
for item_1118 in var_1116 {
{
#[allow(unused_mut)]
let mut object_1119 = array_1117.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_network_acl_entry(
&mut object_1119,
item_1118,
)?;
object_1119.finish();
}
}
array_1117.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elbv2_load_balancer_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElbv2LoadBalancerDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1120) = &input.availability_zones {
let mut array_1121 = object.key("AvailabilityZones").start_array();
for item_1122 in var_1120 {
{
#[allow(unused_mut)]
let mut object_1123 = array_1121.value().start_object();
crate::json_ser::serialize_structure_crate_model_availability_zone(
&mut object_1123,
item_1122,
)?;
object_1123.finish();
}
}
array_1121.finish();
}
if let Some(var_1124) = &input.canonical_hosted_zone_id {
object
.key("CanonicalHostedZoneId")
.string(var_1124.as_str());
}
if let Some(var_1125) = &input.created_time {
object.key("CreatedTime").string(var_1125.as_str());
}
if let Some(var_1126) = &input.dns_name {
object.key("DNSName").string(var_1126.as_str());
}
if let Some(var_1127) = &input.ip_address_type {
object.key("IpAddressType").string(var_1127.as_str());
}
if let Some(var_1128) = &input.scheme {
object.key("Scheme").string(var_1128.as_str());
}
if let Some(var_1129) = &input.security_groups {
let mut array_1130 = object.key("SecurityGroups").start_array();
for item_1131 in var_1129 {
{
array_1130.value().string(item_1131.as_str());
}
}
array_1130.finish();
}
if let Some(var_1132) = &input.state {
#[allow(unused_mut)]
let mut object_1133 = object.key("State").start_object();
crate::json_ser::serialize_structure_crate_model_load_balancer_state(
&mut object_1133,
var_1132,
)?;
object_1133.finish();
}
if let Some(var_1134) = &input.r#type {
object.key("Type").string(var_1134.as_str());
}
if let Some(var_1135) = &input.vpc_id {
object.key("VpcId").string(var_1135.as_str());
}
if let Some(var_1136) = &input.load_balancer_attributes {
let mut array_1137 = object.key("LoadBalancerAttributes").start_array();
for item_1138 in var_1136 {
{
#[allow(unused_mut)]
let mut object_1139 = array_1137.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_elbv2_load_balancer_attribute(
&mut object_1139,
item_1138,
)?;
object_1139.finish();
}
}
array_1137.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elastic_beanstalk_environment_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElasticBeanstalkEnvironmentDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1140) = &input.application_name {
object.key("ApplicationName").string(var_1140.as_str());
}
if let Some(var_1141) = &input.cname {
object.key("Cname").string(var_1141.as_str());
}
if let Some(var_1142) = &input.date_created {
object.key("DateCreated").string(var_1142.as_str());
}
if let Some(var_1143) = &input.date_updated {
object.key("DateUpdated").string(var_1143.as_str());
}
if let Some(var_1144) = &input.description {
object.key("Description").string(var_1144.as_str());
}
if let Some(var_1145) = &input.endpoint_url {
object.key("EndpointUrl").string(var_1145.as_str());
}
if let Some(var_1146) = &input.environment_arn {
object.key("EnvironmentArn").string(var_1146.as_str());
}
if let Some(var_1147) = &input.environment_id {
object.key("EnvironmentId").string(var_1147.as_str());
}
if let Some(var_1148) = &input.environment_links {
let mut array_1149 = object.key("EnvironmentLinks").start_array();
for item_1150 in var_1148 {
{
#[allow(unused_mut)]
let mut object_1151 = array_1149.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_elastic_beanstalk_environment_environment_link(&mut object_1151, item_1150)?;
object_1151.finish();
}
}
array_1149.finish();
}
if let Some(var_1152) = &input.environment_name {
object.key("EnvironmentName").string(var_1152.as_str());
}
if let Some(var_1153) = &input.option_settings {
let mut array_1154 = object.key("OptionSettings").start_array();
for item_1155 in var_1153 {
{
#[allow(unused_mut)]
let mut object_1156 = array_1154.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_elastic_beanstalk_environment_option_setting(&mut object_1156, item_1155)?;
object_1156.finish();
}
}
array_1154.finish();
}
if let Some(var_1157) = &input.platform_arn {
object.key("PlatformArn").string(var_1157.as_str());
}
if let Some(var_1158) = &input.solution_stack_name {
object.key("SolutionStackName").string(var_1158.as_str());
}
if let Some(var_1159) = &input.status {
object.key("Status").string(var_1159.as_str());
}
if let Some(var_1160) = &input.tier {
#[allow(unused_mut)]
let mut object_1161 = object.key("Tier").start_object();
crate::json_ser::serialize_structure_crate_model_aws_elastic_beanstalk_environment_tier(
&mut object_1161,
var_1160,
)?;
object_1161.finish();
}
if let Some(var_1162) = &input.version_label {
object.key("VersionLabel").string(var_1162.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elasticsearch_domain_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElasticsearchDomainDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1163) = &input.access_policies {
object.key("AccessPolicies").string(var_1163.as_str());
}
if let Some(var_1164) = &input.domain_endpoint_options {
#[allow(unused_mut)]
let mut object_1165 = object.key("DomainEndpointOptions").start_object();
crate::json_ser::serialize_structure_crate_model_aws_elasticsearch_domain_domain_endpoint_options(&mut object_1165, var_1164)?;
object_1165.finish();
}
if let Some(var_1166) = &input.domain_id {
object.key("DomainId").string(var_1166.as_str());
}
if let Some(var_1167) = &input.domain_name {
object.key("DomainName").string(var_1167.as_str());
}
if let Some(var_1168) = &input.endpoint {
object.key("Endpoint").string(var_1168.as_str());
}
if let Some(var_1169) = &input.endpoints {
#[allow(unused_mut)]
let mut object_1170 = object.key("Endpoints").start_object();
for (key_1171, value_1172) in var_1169 {
{
object_1170
.key(key_1171.as_str())
.string(value_1172.as_str());
}
}
object_1170.finish();
}
if let Some(var_1173) = &input.elasticsearch_version {
object.key("ElasticsearchVersion").string(var_1173.as_str());
}
if let Some(var_1174) = &input.elasticsearch_cluster_config {
#[allow(unused_mut)]
let mut object_1175 = object.key("ElasticsearchClusterConfig").start_object();
crate::json_ser::serialize_structure_crate_model_aws_elasticsearch_domain_elasticsearch_cluster_config_details(&mut object_1175, var_1174)?;
object_1175.finish();
}
if let Some(var_1176) = &input.encryption_at_rest_options {
#[allow(unused_mut)]
let mut object_1177 = object.key("EncryptionAtRestOptions").start_object();
crate::json_ser::serialize_structure_crate_model_aws_elasticsearch_domain_encryption_at_rest_options(&mut object_1177, var_1176)?;
object_1177.finish();
}
if let Some(var_1178) = &input.log_publishing_options {
#[allow(unused_mut)]
let mut object_1179 = object.key("LogPublishingOptions").start_object();
crate::json_ser::serialize_structure_crate_model_aws_elasticsearch_domain_log_publishing_options(&mut object_1179, var_1178)?;
object_1179.finish();
}
if let Some(var_1180) = &input.node_to_node_encryption_options {
#[allow(unused_mut)]
let mut object_1181 = object.key("NodeToNodeEncryptionOptions").start_object();
crate::json_ser::serialize_structure_crate_model_aws_elasticsearch_domain_node_to_node_encryption_options(&mut object_1181, var_1180)?;
object_1181.finish();
}
if let Some(var_1182) = &input.service_software_options {
#[allow(unused_mut)]
let mut object_1183 = object.key("ServiceSoftwareOptions").start_object();
crate::json_ser::serialize_structure_crate_model_aws_elasticsearch_domain_service_software_options(&mut object_1183, var_1182)?;
object_1183.finish();
}
if let Some(var_1184) = &input.vpc_options {
#[allow(unused_mut)]
let mut object_1185 = object.key("VPCOptions").start_object();
crate::json_ser::serialize_structure_crate_model_aws_elasticsearch_domain_vpc_options(
&mut object_1185,
var_1184,
)?;
object_1185.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1186) = &input.owner_id {
object.key("OwnerId").string(var_1186.as_str());
}
if let Some(var_1187) = &input.owner_name {
object.key("OwnerName").string(var_1187.as_str());
}
if let Some(var_1188) = &input.owner_account_id {
object.key("OwnerAccountId").string(var_1188.as_str());
}
if let Some(var_1189) = &input.created_at {
object.key("CreatedAt").string(var_1189.as_str());
}
if let Some(var_1190) = &input.server_side_encryption_configuration {
#[allow(unused_mut)]
let mut object_1191 = object
.key("ServerSideEncryptionConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_server_side_encryption_configuration(&mut object_1191, var_1190)?;
object_1191.finish();
}
if let Some(var_1192) = &input.bucket_lifecycle_configuration {
#[allow(unused_mut)]
let mut object_1193 = object.key("BucketLifecycleConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_details(&mut object_1193, var_1192)?;
object_1193.finish();
}
if let Some(var_1194) = &input.public_access_block_configuration {
#[allow(unused_mut)]
let mut object_1195 = object.key("PublicAccessBlockConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_account_public_access_block_details(&mut object_1195, var_1194)?;
object_1195.finish();
}
if let Some(var_1196) = &input.access_control_list {
object.key("AccessControlList").string(var_1196.as_str());
}
if let Some(var_1197) = &input.bucket_logging_configuration {
#[allow(unused_mut)]
let mut object_1198 = object.key("BucketLoggingConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_logging_configuration(
&mut object_1198,
var_1197,
)?;
object_1198.finish();
}
if let Some(var_1199) = &input.bucket_website_configuration {
#[allow(unused_mut)]
let mut object_1200 = object.key("BucketWebsiteConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_website_configuration(
&mut object_1200,
var_1199,
)?;
object_1200.finish();
}
if let Some(var_1201) = &input.bucket_notification_configuration {
#[allow(unused_mut)]
let mut object_1202 = object.key("BucketNotificationConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_notification_configuration(
&mut object_1202,
var_1201,
)?;
object_1202.finish();
}
if let Some(var_1203) = &input.bucket_versioning_configuration {
#[allow(unused_mut)]
let mut object_1204 = object.key("BucketVersioningConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_bucket_versioning_configuration(&mut object_1204, var_1203)?;
object_1204.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_account_public_access_block_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3AccountPublicAccessBlockDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.block_public_acls {
object
.key("BlockPublicAcls")
.boolean(input.block_public_acls);
}
if input.block_public_policy {
object
.key("BlockPublicPolicy")
.boolean(input.block_public_policy);
}
if input.ignore_public_acls {
object
.key("IgnorePublicAcls")
.boolean(input.ignore_public_acls);
}
if input.restrict_public_buckets {
object
.key("RestrictPublicBuckets")
.boolean(input.restrict_public_buckets);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_object_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3ObjectDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1205) = &input.last_modified {
object.key("LastModified").string(var_1205.as_str());
}
if let Some(var_1206) = &input.e_tag {
object.key("ETag").string(var_1206.as_str());
}
if let Some(var_1207) = &input.version_id {
object.key("VersionId").string(var_1207.as_str());
}
if let Some(var_1208) = &input.content_type {
object.key("ContentType").string(var_1208.as_str());
}
if let Some(var_1209) = &input.server_side_encryption {
object.key("ServerSideEncryption").string(var_1209.as_str());
}
if let Some(var_1210) = &input.ssekms_key_id {
object.key("SSEKMSKeyId").string(var_1210.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_secrets_manager_secret_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsSecretsManagerSecretDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1211) = &input.rotation_rules {
#[allow(unused_mut)]
let mut object_1212 = object.key("RotationRules").start_object();
crate::json_ser::serialize_structure_crate_model_aws_secrets_manager_secret_rotation_rules(
&mut object_1212,
var_1211,
)?;
object_1212.finish();
}
if input.rotation_occurred_within_frequency {
object
.key("RotationOccurredWithinFrequency")
.boolean(input.rotation_occurred_within_frequency);
}
if let Some(var_1213) = &input.kms_key_id {
object.key("KmsKeyId").string(var_1213.as_str());
}
if input.rotation_enabled {
object
.key("RotationEnabled")
.boolean(input.rotation_enabled);
}
if let Some(var_1214) = &input.rotation_lambda_arn {
object.key("RotationLambdaArn").string(var_1214.as_str());
}
if input.deleted {
object.key("Deleted").boolean(input.deleted);
}
if let Some(var_1215) = &input.name {
object.key("Name").string(var_1215.as_str());
}
if let Some(var_1216) = &input.description {
object.key("Description").string(var_1216.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_iam_access_key_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsIamAccessKeyDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1217) = &input.user_name {
object.key("UserName").string(var_1217.as_str());
}
if let Some(var_1218) = &input.status {
object.key("Status").string(var_1218.as_str());
}
if let Some(var_1219) = &input.created_at {
object.key("CreatedAt").string(var_1219.as_str());
}
if let Some(var_1220) = &input.principal_id {
object.key("PrincipalId").string(var_1220.as_str());
}
if let Some(var_1221) = &input.principal_type {
object.key("PrincipalType").string(var_1221.as_str());
}
if let Some(var_1222) = &input.principal_name {
object.key("PrincipalName").string(var_1222.as_str());
}
if let Some(var_1223) = &input.account_id {
object.key("AccountId").string(var_1223.as_str());
}
if let Some(var_1224) = &input.access_key_id {
object.key("AccessKeyId").string(var_1224.as_str());
}
if let Some(var_1225) = &input.session_context {
#[allow(unused_mut)]
let mut object_1226 = object.key("SessionContext").start_object();
crate::json_ser::serialize_structure_crate_model_aws_iam_access_key_session_context(
&mut object_1226,
var_1225,
)?;
object_1226.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_iam_user_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsIamUserDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1227) = &input.attached_managed_policies {
let mut array_1228 = object.key("AttachedManagedPolicies").start_array();
for item_1229 in var_1227 {
{
#[allow(unused_mut)]
let mut object_1230 = array_1228.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_iam_attached_managed_policy(
&mut object_1230,
item_1229,
)?;
object_1230.finish();
}
}
array_1228.finish();
}
if let Some(var_1231) = &input.create_date {
object.key("CreateDate").string(var_1231.as_str());
}
if let Some(var_1232) = &input.group_list {
let mut array_1233 = object.key("GroupList").start_array();
for item_1234 in var_1232 {
{
array_1233.value().string(item_1234.as_str());
}
}
array_1233.finish();
}
if let Some(var_1235) = &input.path {
object.key("Path").string(var_1235.as_str());
}
if let Some(var_1236) = &input.permissions_boundary {
#[allow(unused_mut)]
let mut object_1237 = object.key("PermissionsBoundary").start_object();
crate::json_ser::serialize_structure_crate_model_aws_iam_permissions_boundary(
&mut object_1237,
var_1236,
)?;
object_1237.finish();
}
if let Some(var_1238) = &input.user_id {
object.key("UserId").string(var_1238.as_str());
}
if let Some(var_1239) = &input.user_name {
object.key("UserName").string(var_1239.as_str());
}
if let Some(var_1240) = &input.user_policy_list {
let mut array_1241 = object.key("UserPolicyList").start_array();
for item_1242 in var_1240 {
{
#[allow(unused_mut)]
let mut object_1243 = array_1241.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_iam_user_policy(
&mut object_1243,
item_1242,
)?;
object_1243.finish();
}
}
array_1241.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_iam_policy_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsIamPolicyDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.attachment_count != 0 {
object.key("AttachmentCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.attachment_count).into()),
);
}
if let Some(var_1244) = &input.create_date {
object.key("CreateDate").string(var_1244.as_str());
}
if let Some(var_1245) = &input.default_version_id {
object.key("DefaultVersionId").string(var_1245.as_str());
}
if let Some(var_1246) = &input.description {
object.key("Description").string(var_1246.as_str());
}
if input.is_attachable {
object.key("IsAttachable").boolean(input.is_attachable);
}
if let Some(var_1247) = &input.path {
object.key("Path").string(var_1247.as_str());
}
if input.permissions_boundary_usage_count != 0 {
object.key("PermissionsBoundaryUsageCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.permissions_boundary_usage_count).into()),
);
}
if let Some(var_1248) = &input.policy_id {
object.key("PolicyId").string(var_1248.as_str());
}
if let Some(var_1249) = &input.policy_name {
object.key("PolicyName").string(var_1249.as_str());
}
if let Some(var_1250) = &input.policy_version_list {
let mut array_1251 = object.key("PolicyVersionList").start_array();
for item_1252 in var_1250 {
{
#[allow(unused_mut)]
let mut object_1253 = array_1251.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_iam_policy_version(
&mut object_1253,
item_1252,
)?;
object_1253.finish();
}
}
array_1251.finish();
}
if let Some(var_1254) = &input.update_date {
object.key("UpdateDate").string(var_1254.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_api_gateway_v2_stage_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsApiGatewayV2StageDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1255) = &input.client_certificate_id {
object.key("ClientCertificateId").string(var_1255.as_str());
}
if let Some(var_1256) = &input.created_date {
object.key("CreatedDate").string(var_1256.as_str());
}
if let Some(var_1257) = &input.description {
object.key("Description").string(var_1257.as_str());
}
if let Some(var_1258) = &input.default_route_settings {
#[allow(unused_mut)]
let mut object_1259 = object.key("DefaultRouteSettings").start_object();
crate::json_ser::serialize_structure_crate_model_aws_api_gateway_v2_route_settings(
&mut object_1259,
var_1258,
)?;
object_1259.finish();
}
if let Some(var_1260) = &input.deployment_id {
object.key("DeploymentId").string(var_1260.as_str());
}
if let Some(var_1261) = &input.last_updated_date {
object.key("LastUpdatedDate").string(var_1261.as_str());
}
if let Some(var_1262) = &input.route_settings {
#[allow(unused_mut)]
let mut object_1263 = object.key("RouteSettings").start_object();
crate::json_ser::serialize_structure_crate_model_aws_api_gateway_v2_route_settings(
&mut object_1263,
var_1262,
)?;
object_1263.finish();
}
if let Some(var_1264) = &input.stage_name {
object.key("StageName").string(var_1264.as_str());
}
if let Some(var_1265) = &input.stage_variables {
#[allow(unused_mut)]
let mut object_1266 = object.key("StageVariables").start_object();
for (key_1267, value_1268) in var_1265 {
{
object_1266
.key(key_1267.as_str())
.string(value_1268.as_str());
}
}
object_1266.finish();
}
if let Some(var_1269) = &input.access_log_settings {
#[allow(unused_mut)]
let mut object_1270 = object.key("AccessLogSettings").start_object();
crate::json_ser::serialize_structure_crate_model_aws_api_gateway_access_log_settings(
&mut object_1270,
var_1269,
)?;
object_1270.finish();
}
if input.auto_deploy {
object.key("AutoDeploy").boolean(input.auto_deploy);
}
if let Some(var_1271) = &input.last_deployment_status_message {
object
.key("LastDeploymentStatusMessage")
.string(var_1271.as_str());
}
if input.api_gateway_managed {
object
.key("ApiGatewayManaged")
.boolean(input.api_gateway_managed);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_api_gateway_v2_api_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsApiGatewayV2ApiDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1272) = &input.api_endpoint {
object.key("ApiEndpoint").string(var_1272.as_str());
}
if let Some(var_1273) = &input.api_id {
object.key("ApiId").string(var_1273.as_str());
}
if let Some(var_1274) = &input.api_key_selection_expression {
object
.key("ApiKeySelectionExpression")
.string(var_1274.as_str());
}
if let Some(var_1275) = &input.created_date {
object.key("CreatedDate").string(var_1275.as_str());
}
if let Some(var_1276) = &input.description {
object.key("Description").string(var_1276.as_str());
}
if let Some(var_1277) = &input.version {
object.key("Version").string(var_1277.as_str());
}
if let Some(var_1278) = &input.name {
object.key("Name").string(var_1278.as_str());
}
if let Some(var_1279) = &input.protocol_type {
object.key("ProtocolType").string(var_1279.as_str());
}
if let Some(var_1280) = &input.route_selection_expression {
object
.key("RouteSelectionExpression")
.string(var_1280.as_str());
}
if let Some(var_1281) = &input.cors_configuration {
#[allow(unused_mut)]
let mut object_1282 = object.key("CorsConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_aws_cors_configuration(
&mut object_1282,
var_1281,
)?;
object_1282.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_dynamo_db_table_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsDynamoDbTableDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1283) = &input.attribute_definitions {
let mut array_1284 = object.key("AttributeDefinitions").start_array();
for item_1285 in var_1283 {
{
#[allow(unused_mut)]
let mut object_1286 = array_1284.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_attribute_definition(&mut object_1286, item_1285)?;
object_1286.finish();
}
}
array_1284.finish();
}
if let Some(var_1287) = &input.billing_mode_summary {
#[allow(unused_mut)]
let mut object_1288 = object.key("BillingModeSummary").start_object();
crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_billing_mode_summary(
&mut object_1288,
var_1287,
)?;
object_1288.finish();
}
if let Some(var_1289) = &input.creation_date_time {
object.key("CreationDateTime").string(var_1289.as_str());
}
if let Some(var_1290) = &input.global_secondary_indexes {
let mut array_1291 = object.key("GlobalSecondaryIndexes").start_array();
for item_1292 in var_1290 {
{
#[allow(unused_mut)]
let mut object_1293 = array_1291.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_global_secondary_index(&mut object_1293, item_1292)?;
object_1293.finish();
}
}
array_1291.finish();
}
if let Some(var_1294) = &input.global_table_version {
object.key("GlobalTableVersion").string(var_1294.as_str());
}
if input.item_count != 0 {
object.key("ItemCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.item_count).into()),
);
}
if let Some(var_1295) = &input.key_schema {
let mut array_1296 = object.key("KeySchema").start_array();
for item_1297 in var_1295 {
{
#[allow(unused_mut)]
let mut object_1298 = array_1296.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_key_schema(
&mut object_1298,
item_1297,
)?;
object_1298.finish();
}
}
array_1296.finish();
}
if let Some(var_1299) = &input.latest_stream_arn {
object.key("LatestStreamArn").string(var_1299.as_str());
}
if let Some(var_1300) = &input.latest_stream_label {
object.key("LatestStreamLabel").string(var_1300.as_str());
}
if let Some(var_1301) = &input.local_secondary_indexes {
let mut array_1302 = object.key("LocalSecondaryIndexes").start_array();
for item_1303 in var_1301 {
{
#[allow(unused_mut)]
let mut object_1304 = array_1302.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_local_secondary_index(&mut object_1304, item_1303)?;
object_1304.finish();
}
}
array_1302.finish();
}
if let Some(var_1305) = &input.provisioned_throughput {
#[allow(unused_mut)]
let mut object_1306 = object.key("ProvisionedThroughput").start_object();
crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_provisioned_throughput(&mut object_1306, var_1305)?;
object_1306.finish();
}
if let Some(var_1307) = &input.replicas {
let mut array_1308 = object.key("Replicas").start_array();
for item_1309 in var_1307 {
{
#[allow(unused_mut)]
let mut object_1310 = array_1308.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_replica(
&mut object_1310,
item_1309,
)?;
object_1310.finish();
}
}
array_1308.finish();
}
if let Some(var_1311) = &input.restore_summary {
#[allow(unused_mut)]
let mut object_1312 = object.key("RestoreSummary").start_object();
crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_restore_summary(
&mut object_1312,
var_1311,
)?;
object_1312.finish();
}
if let Some(var_1313) = &input.sse_description {
#[allow(unused_mut)]
let mut object_1314 = object.key("SseDescription").start_object();
crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_sse_description(
&mut object_1314,
var_1313,
)?;
object_1314.finish();
}
if let Some(var_1315) = &input.stream_specification {
#[allow(unused_mut)]
let mut object_1316 = object.key("StreamSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_stream_specification(
&mut object_1316,
var_1315,
)?;
object_1316.finish();
}
if let Some(var_1317) = &input.table_id {
object.key("TableId").string(var_1317.as_str());
}
if let Some(var_1318) = &input.table_name {
object.key("TableName").string(var_1318.as_str());
}
if input.table_size_bytes != 0 {
object.key("TableSizeBytes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.table_size_bytes).into()),
);
}
if let Some(var_1319) = &input.table_status {
object.key("TableStatus").string(var_1319.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_api_gateway_stage_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsApiGatewayStageDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1320) = &input.deployment_id {
object.key("DeploymentId").string(var_1320.as_str());
}
if let Some(var_1321) = &input.client_certificate_id {
object.key("ClientCertificateId").string(var_1321.as_str());
}
if let Some(var_1322) = &input.stage_name {
object.key("StageName").string(var_1322.as_str());
}
if let Some(var_1323) = &input.description {
object.key("Description").string(var_1323.as_str());
}
if input.cache_cluster_enabled {
object
.key("CacheClusterEnabled")
.boolean(input.cache_cluster_enabled);
}
if let Some(var_1324) = &input.cache_cluster_size {
object.key("CacheClusterSize").string(var_1324.as_str());
}
if let Some(var_1325) = &input.cache_cluster_status {
object.key("CacheClusterStatus").string(var_1325.as_str());
}
if let Some(var_1326) = &input.method_settings {
let mut array_1327 = object.key("MethodSettings").start_array();
for item_1328 in var_1326 {
{
#[allow(unused_mut)]
let mut object_1329 = array_1327.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_api_gateway_method_settings(
&mut object_1329,
item_1328,
)?;
object_1329.finish();
}
}
array_1327.finish();
}
if let Some(var_1330) = &input.variables {
#[allow(unused_mut)]
let mut object_1331 = object.key("Variables").start_object();
for (key_1332, value_1333) in var_1330 {
{
object_1331
.key(key_1332.as_str())
.string(value_1333.as_str());
}
}
object_1331.finish();
}
if let Some(var_1334) = &input.documentation_version {
object.key("DocumentationVersion").string(var_1334.as_str());
}
if let Some(var_1335) = &input.access_log_settings {
#[allow(unused_mut)]
let mut object_1336 = object.key("AccessLogSettings").start_object();
crate::json_ser::serialize_structure_crate_model_aws_api_gateway_access_log_settings(
&mut object_1336,
var_1335,
)?;
object_1336.finish();
}
if let Some(var_1337) = &input.canary_settings {
#[allow(unused_mut)]
let mut object_1338 = object.key("CanarySettings").start_object();
crate::json_ser::serialize_structure_crate_model_aws_api_gateway_canary_settings(
&mut object_1338,
var_1337,
)?;
object_1338.finish();
}
if input.tracing_enabled {
object.key("TracingEnabled").boolean(input.tracing_enabled);
}
if let Some(var_1339) = &input.created_date {
object.key("CreatedDate").string(var_1339.as_str());
}
if let Some(var_1340) = &input.last_updated_date {
object.key("LastUpdatedDate").string(var_1340.as_str());
}
if let Some(var_1341) = &input.web_acl_arn {
object.key("WebAclArn").string(var_1341.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_api_gateway_rest_api_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsApiGatewayRestApiDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1342) = &input.id {
object.key("Id").string(var_1342.as_str());
}
if let Some(var_1343) = &input.name {
object.key("Name").string(var_1343.as_str());
}
if let Some(var_1344) = &input.description {
object.key("Description").string(var_1344.as_str());
}
if let Some(var_1345) = &input.created_date {
object.key("CreatedDate").string(var_1345.as_str());
}
if let Some(var_1346) = &input.version {
object.key("Version").string(var_1346.as_str());
}
if let Some(var_1347) = &input.binary_media_types {
let mut array_1348 = object.key("BinaryMediaTypes").start_array();
for item_1349 in var_1347 {
{
array_1348.value().string(item_1349.as_str());
}
}
array_1348.finish();
}
if input.minimum_compression_size != 0 {
object.key("MinimumCompressionSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.minimum_compression_size).into()),
);
}
if let Some(var_1350) = &input.api_key_source {
object.key("ApiKeySource").string(var_1350.as_str());
}
if let Some(var_1351) = &input.endpoint_configuration {
#[allow(unused_mut)]
let mut object_1352 = object.key("EndpointConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_aws_api_gateway_endpoint_configuration(
&mut object_1352,
var_1351,
)?;
object_1352.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_cloud_trail_trail_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCloudTrailTrailDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1353) = &input.cloud_watch_logs_log_group_arn {
object
.key("CloudWatchLogsLogGroupArn")
.string(var_1353.as_str());
}
if let Some(var_1354) = &input.cloud_watch_logs_role_arn {
object
.key("CloudWatchLogsRoleArn")
.string(var_1354.as_str());
}
if input.has_custom_event_selectors {
object
.key("HasCustomEventSelectors")
.boolean(input.has_custom_event_selectors);
}
if let Some(var_1355) = &input.home_region {
object.key("HomeRegion").string(var_1355.as_str());
}
if input.include_global_service_events {
object
.key("IncludeGlobalServiceEvents")
.boolean(input.include_global_service_events);
}
if input.is_multi_region_trail {
object
.key("IsMultiRegionTrail")
.boolean(input.is_multi_region_trail);
}
if input.is_organization_trail {
object
.key("IsOrganizationTrail")
.boolean(input.is_organization_trail);
}
if let Some(var_1356) = &input.kms_key_id {
object.key("KmsKeyId").string(var_1356.as_str());
}
if input.log_file_validation_enabled {
object
.key("LogFileValidationEnabled")
.boolean(input.log_file_validation_enabled);
}
if let Some(var_1357) = &input.name {
object.key("Name").string(var_1357.as_str());
}
if let Some(var_1358) = &input.s3_bucket_name {
object.key("S3BucketName").string(var_1358.as_str());
}
if let Some(var_1359) = &input.s3_key_prefix {
object.key("S3KeyPrefix").string(var_1359.as_str());
}
if let Some(var_1360) = &input.sns_topic_arn {
object.key("SnsTopicArn").string(var_1360.as_str());
}
if let Some(var_1361) = &input.sns_topic_name {
object.key("SnsTopicName").string(var_1361.as_str());
}
if let Some(var_1362) = &input.trail_arn {
object.key("TrailArn").string(var_1362.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ssm_patch_compliance_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsSsmPatchComplianceDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1363) = &input.patch {
#[allow(unused_mut)]
let mut object_1364 = object.key("Patch").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ssm_patch(&mut object_1364, var_1363)?;
object_1364.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_certificate_manager_certificate_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCertificateManagerCertificateDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1365) = &input.certificate_authority_arn {
object
.key("CertificateAuthorityArn")
.string(var_1365.as_str());
}
if let Some(var_1366) = &input.created_at {
object.key("CreatedAt").string(var_1366.as_str());
}
if let Some(var_1367) = &input.domain_name {
object.key("DomainName").string(var_1367.as_str());
}
if let Some(var_1368) = &input.domain_validation_options {
let mut array_1369 = object.key("DomainValidationOptions").start_array();
for item_1370 in var_1368 {
{
#[allow(unused_mut)]
let mut object_1371 = array_1369.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_certificate_manager_certificate_domain_validation_option(&mut object_1371, item_1370)?;
object_1371.finish();
}
}
array_1369.finish();
}
if let Some(var_1372) = &input.extended_key_usages {
let mut array_1373 = object.key("ExtendedKeyUsages").start_array();
for item_1374 in var_1372 {
{
#[allow(unused_mut)]
let mut object_1375 = array_1373.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_certificate_manager_certificate_extended_key_usage(&mut object_1375, item_1374)?;
object_1375.finish();
}
}
array_1373.finish();
}
if let Some(var_1376) = &input.failure_reason {
object.key("FailureReason").string(var_1376.as_str());
}
if let Some(var_1377) = &input.imported_at {
object.key("ImportedAt").string(var_1377.as_str());
}
if let Some(var_1378) = &input.in_use_by {
let mut array_1379 = object.key("InUseBy").start_array();
for item_1380 in var_1378 {
{
array_1379.value().string(item_1380.as_str());
}
}
array_1379.finish();
}
if let Some(var_1381) = &input.issued_at {
object.key("IssuedAt").string(var_1381.as_str());
}
if let Some(var_1382) = &input.issuer {
object.key("Issuer").string(var_1382.as_str());
}
if let Some(var_1383) = &input.key_algorithm {
object.key("KeyAlgorithm").string(var_1383.as_str());
}
if let Some(var_1384) = &input.key_usages {
let mut array_1385 = object.key("KeyUsages").start_array();
for item_1386 in var_1384 {
{
#[allow(unused_mut)]
let mut object_1387 = array_1385.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_certificate_manager_certificate_key_usage(&mut object_1387, item_1386)?;
object_1387.finish();
}
}
array_1385.finish();
}
if let Some(var_1388) = &input.not_after {
object.key("NotAfter").string(var_1388.as_str());
}
if let Some(var_1389) = &input.not_before {
object.key("NotBefore").string(var_1389.as_str());
}
if let Some(var_1390) = &input.options {
#[allow(unused_mut)]
let mut object_1391 = object.key("Options").start_object();
crate::json_ser::serialize_structure_crate_model_aws_certificate_manager_certificate_options(&mut object_1391, var_1390)?;
object_1391.finish();
}
if let Some(var_1392) = &input.renewal_eligibility {
object.key("RenewalEligibility").string(var_1392.as_str());
}
if let Some(var_1393) = &input.renewal_summary {
#[allow(unused_mut)]
let mut object_1394 = object.key("RenewalSummary").start_object();
crate::json_ser::serialize_structure_crate_model_aws_certificate_manager_certificate_renewal_summary(&mut object_1394, var_1393)?;
object_1394.finish();
}
if let Some(var_1395) = &input.serial {
object.key("Serial").string(var_1395.as_str());
}
if let Some(var_1396) = &input.signature_algorithm {
object.key("SignatureAlgorithm").string(var_1396.as_str());
}
if let Some(var_1397) = &input.status {
object.key("Status").string(var_1397.as_str());
}
if let Some(var_1398) = &input.subject {
object.key("Subject").string(var_1398.as_str());
}
if let Some(var_1399) = &input.subject_alternative_names {
let mut array_1400 = object.key("SubjectAlternativeNames").start_array();
for item_1401 in var_1399 {
{
array_1400.value().string(item_1401.as_str());
}
}
array_1400.finish();
}
if let Some(var_1402) = &input.r#type {
object.key("Type").string(var_1402.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_redshift_cluster_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRedshiftClusterDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.allow_version_upgrade {
object
.key("AllowVersionUpgrade")
.boolean(input.allow_version_upgrade);
}
if input.automated_snapshot_retention_period != 0 {
object.key("AutomatedSnapshotRetentionPeriod").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.automated_snapshot_retention_period).into()),
);
}
if let Some(var_1403) = &input.availability_zone {
object.key("AvailabilityZone").string(var_1403.as_str());
}
if let Some(var_1404) = &input.cluster_availability_status {
object
.key("ClusterAvailabilityStatus")
.string(var_1404.as_str());
}
if let Some(var_1405) = &input.cluster_create_time {
object.key("ClusterCreateTime").string(var_1405.as_str());
}
if let Some(var_1406) = &input.cluster_identifier {
object.key("ClusterIdentifier").string(var_1406.as_str());
}
if let Some(var_1407) = &input.cluster_nodes {
let mut array_1408 = object.key("ClusterNodes").start_array();
for item_1409 in var_1407 {
{
#[allow(unused_mut)]
let mut object_1410 = array_1408.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_cluster_node(
&mut object_1410,
item_1409,
)?;
object_1410.finish();
}
}
array_1408.finish();
}
if let Some(var_1411) = &input.cluster_parameter_groups {
let mut array_1412 = object.key("ClusterParameterGroups").start_array();
for item_1413 in var_1411 {
{
#[allow(unused_mut)]
let mut object_1414 = array_1412.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_cluster_parameter_group(&mut object_1414, item_1413)?;
object_1414.finish();
}
}
array_1412.finish();
}
if let Some(var_1415) = &input.cluster_public_key {
object.key("ClusterPublicKey").string(var_1415.as_str());
}
if let Some(var_1416) = &input.cluster_revision_number {
object
.key("ClusterRevisionNumber")
.string(var_1416.as_str());
}
if let Some(var_1417) = &input.cluster_security_groups {
let mut array_1418 = object.key("ClusterSecurityGroups").start_array();
for item_1419 in var_1417 {
{
#[allow(unused_mut)]
let mut object_1420 = array_1418.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_cluster_security_group(&mut object_1420, item_1419)?;
object_1420.finish();
}
}
array_1418.finish();
}
if let Some(var_1421) = &input.cluster_snapshot_copy_status {
#[allow(unused_mut)]
let mut object_1422 = object.key("ClusterSnapshotCopyStatus").start_object();
crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_cluster_snapshot_copy_status(&mut object_1422, var_1421)?;
object_1422.finish();
}
if let Some(var_1423) = &input.cluster_status {
object.key("ClusterStatus").string(var_1423.as_str());
}
if let Some(var_1424) = &input.cluster_subnet_group_name {
object
.key("ClusterSubnetGroupName")
.string(var_1424.as_str());
}
if let Some(var_1425) = &input.cluster_version {
object.key("ClusterVersion").string(var_1425.as_str());
}
if let Some(var_1426) = &input.db_name {
object.key("DBName").string(var_1426.as_str());
}
if let Some(var_1427) = &input.deferred_maintenance_windows {
let mut array_1428 = object.key("DeferredMaintenanceWindows").start_array();
for item_1429 in var_1427 {
{
#[allow(unused_mut)]
let mut object_1430 = array_1428.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_deferred_maintenance_window(&mut object_1430, item_1429)?;
object_1430.finish();
}
}
array_1428.finish();
}
if let Some(var_1431) = &input.elastic_ip_status {
#[allow(unused_mut)]
let mut object_1432 = object.key("ElasticIpStatus").start_object();
crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_elastic_ip_status(
&mut object_1432,
var_1431,
)?;
object_1432.finish();
}
if let Some(var_1433) = &input.elastic_resize_number_of_node_options {
object
.key("ElasticResizeNumberOfNodeOptions")
.string(var_1433.as_str());
}
if input.encrypted {
object.key("Encrypted").boolean(input.encrypted);
}
if let Some(var_1434) = &input.endpoint {
#[allow(unused_mut)]
let mut object_1435 = object.key("Endpoint").start_object();
crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_endpoint(
&mut object_1435,
var_1434,
)?;
object_1435.finish();
}
if input.enhanced_vpc_routing {
object
.key("EnhancedVpcRouting")
.boolean(input.enhanced_vpc_routing);
}
if let Some(var_1436) = &input.expected_next_snapshot_schedule_time {
object
.key("ExpectedNextSnapshotScheduleTime")
.string(var_1436.as_str());
}
if let Some(var_1437) = &input.expected_next_snapshot_schedule_time_status {
object
.key("ExpectedNextSnapshotScheduleTimeStatus")
.string(var_1437.as_str());
}
if let Some(var_1438) = &input.hsm_status {
#[allow(unused_mut)]
let mut object_1439 = object.key("HsmStatus").start_object();
crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_hsm_status(
&mut object_1439,
var_1438,
)?;
object_1439.finish();
}
if let Some(var_1440) = &input.iam_roles {
let mut array_1441 = object.key("IamRoles").start_array();
for item_1442 in var_1440 {
{
#[allow(unused_mut)]
let mut object_1443 = array_1441.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_iam_role(
&mut object_1443,
item_1442,
)?;
object_1443.finish();
}
}
array_1441.finish();
}
if let Some(var_1444) = &input.kms_key_id {
object.key("KmsKeyId").string(var_1444.as_str());
}
if let Some(var_1445) = &input.maintenance_track_name {
object.key("MaintenanceTrackName").string(var_1445.as_str());
}
if input.manual_snapshot_retention_period != 0 {
object.key("ManualSnapshotRetentionPeriod").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.manual_snapshot_retention_period).into()),
);
}
if let Some(var_1446) = &input.master_username {
object.key("MasterUsername").string(var_1446.as_str());
}
if let Some(var_1447) = &input.next_maintenance_window_start_time {
object
.key("NextMaintenanceWindowStartTime")
.string(var_1447.as_str());
}
if let Some(var_1448) = &input.node_type {
object.key("NodeType").string(var_1448.as_str());
}
if input.number_of_nodes != 0 {
object.key("NumberOfNodes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.number_of_nodes).into()),
);
}
if let Some(var_1449) = &input.pending_actions {
let mut array_1450 = object.key("PendingActions").start_array();
for item_1451 in var_1449 {
{
array_1450.value().string(item_1451.as_str());
}
}
array_1450.finish();
}
if let Some(var_1452) = &input.pending_modified_values {
#[allow(unused_mut)]
let mut object_1453 = object.key("PendingModifiedValues").start_object();
crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_pending_modified_values(&mut object_1453, var_1452)?;
object_1453.finish();
}
if let Some(var_1454) = &input.preferred_maintenance_window {
object
.key("PreferredMaintenanceWindow")
.string(var_1454.as_str());
}
if input.publicly_accessible {
object
.key("PubliclyAccessible")
.boolean(input.publicly_accessible);
}
if let Some(var_1455) = &input.resize_info {
#[allow(unused_mut)]
let mut object_1456 = object.key("ResizeInfo").start_object();
crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_resize_info(
&mut object_1456,
var_1455,
)?;
object_1456.finish();
}
if let Some(var_1457) = &input.restore_status {
#[allow(unused_mut)]
let mut object_1458 = object.key("RestoreStatus").start_object();
crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_restore_status(
&mut object_1458,
var_1457,
)?;
object_1458.finish();
}
if let Some(var_1459) = &input.snapshot_schedule_identifier {
object
.key("SnapshotScheduleIdentifier")
.string(var_1459.as_str());
}
if let Some(var_1460) = &input.snapshot_schedule_state {
object
.key("SnapshotScheduleState")
.string(var_1460.as_str());
}
if let Some(var_1461) = &input.vpc_id {
object.key("VpcId").string(var_1461.as_str());
}
if let Some(var_1462) = &input.vpc_security_groups {
let mut array_1463 = object.key("VpcSecurityGroups").start_array();
for item_1464 in var_1462 {
{
#[allow(unused_mut)]
let mut object_1465 = array_1463.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_vpc_security_group(&mut object_1465, item_1464)?;
object_1465.finish();
}
}
array_1463.finish();
}
if let Some(var_1466) = &input.logging_status {
#[allow(unused_mut)]
let mut object_1467 = object.key("LoggingStatus").start_object();
crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_logging_status(
&mut object_1467,
var_1466,
)?;
object_1467.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elb_load_balancer_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElbLoadBalancerDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1468) = &input.availability_zones {
let mut array_1469 = object.key("AvailabilityZones").start_array();
for item_1470 in var_1468 {
{
array_1469.value().string(item_1470.as_str());
}
}
array_1469.finish();
}
if let Some(var_1471) = &input.backend_server_descriptions {
let mut array_1472 = object.key("BackendServerDescriptions").start_array();
for item_1473 in var_1471 {
{
#[allow(unused_mut)]
let mut object_1474 = array_1472.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_backend_server_description(&mut object_1474, item_1473)?;
object_1474.finish();
}
}
array_1472.finish();
}
if let Some(var_1475) = &input.canonical_hosted_zone_name {
object
.key("CanonicalHostedZoneName")
.string(var_1475.as_str());
}
if let Some(var_1476) = &input.canonical_hosted_zone_name_id {
object
.key("CanonicalHostedZoneNameID")
.string(var_1476.as_str());
}
if let Some(var_1477) = &input.created_time {
object.key("CreatedTime").string(var_1477.as_str());
}
if let Some(var_1478) = &input.dns_name {
object.key("DnsName").string(var_1478.as_str());
}
if let Some(var_1479) = &input.health_check {
#[allow(unused_mut)]
let mut object_1480 = object.key("HealthCheck").start_object();
crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_health_check(
&mut object_1480,
var_1479,
)?;
object_1480.finish();
}
if let Some(var_1481) = &input.instances {
let mut array_1482 = object.key("Instances").start_array();
for item_1483 in var_1481 {
{
#[allow(unused_mut)]
let mut object_1484 = array_1482.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_instance(
&mut object_1484,
item_1483,
)?;
object_1484.finish();
}
}
array_1482.finish();
}
if let Some(var_1485) = &input.listener_descriptions {
let mut array_1486 = object.key("ListenerDescriptions").start_array();
for item_1487 in var_1485 {
{
#[allow(unused_mut)]
let mut object_1488 = array_1486.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_listener_description(&mut object_1488, item_1487)?;
object_1488.finish();
}
}
array_1486.finish();
}
if let Some(var_1489) = &input.load_balancer_attributes {
#[allow(unused_mut)]
let mut object_1490 = object.key("LoadBalancerAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_attributes(
&mut object_1490,
var_1489,
)?;
object_1490.finish();
}
if let Some(var_1491) = &input.load_balancer_name {
object.key("LoadBalancerName").string(var_1491.as_str());
}
if let Some(var_1492) = &input.policies {
#[allow(unused_mut)]
let mut object_1493 = object.key("Policies").start_object();
crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_policies(
&mut object_1493,
var_1492,
)?;
object_1493.finish();
}
if let Some(var_1494) = &input.scheme {
object.key("Scheme").string(var_1494.as_str());
}
if let Some(var_1495) = &input.security_groups {
let mut array_1496 = object.key("SecurityGroups").start_array();
for item_1497 in var_1495 {
{
array_1496.value().string(item_1497.as_str());
}
}
array_1496.finish();
}
if let Some(var_1498) = &input.source_security_group {
#[allow(unused_mut)]
let mut object_1499 = object.key("SourceSecurityGroup").start_object();
crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_source_security_group(&mut object_1499, var_1498)?;
object_1499.finish();
}
if let Some(var_1500) = &input.subnets {
let mut array_1501 = object.key("Subnets").start_array();
for item_1502 in var_1500 {
{
array_1501.value().string(item_1502.as_str());
}
}
array_1501.finish();
}
if let Some(var_1503) = &input.vpc_id {
object.key("VpcId").string(var_1503.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_iam_group_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsIamGroupDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1504) = &input.attached_managed_policies {
let mut array_1505 = object.key("AttachedManagedPolicies").start_array();
for item_1506 in var_1504 {
{
#[allow(unused_mut)]
let mut object_1507 = array_1505.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_iam_attached_managed_policy(
&mut object_1507,
item_1506,
)?;
object_1507.finish();
}
}
array_1505.finish();
}
if let Some(var_1508) = &input.create_date {
object.key("CreateDate").string(var_1508.as_str());
}
if let Some(var_1509) = &input.group_id {
object.key("GroupId").string(var_1509.as_str());
}
if let Some(var_1510) = &input.group_name {
object.key("GroupName").string(var_1510.as_str());
}
if let Some(var_1511) = &input.group_policy_list {
let mut array_1512 = object.key("GroupPolicyList").start_array();
for item_1513 in var_1511 {
{
#[allow(unused_mut)]
let mut object_1514 = array_1512.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_iam_group_policy(
&mut object_1514,
item_1513,
)?;
object_1514.finish();
}
}
array_1512.finish();
}
if let Some(var_1515) = &input.path {
object.key("Path").string(var_1515.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_iam_role_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsIamRoleDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1516) = &input.assume_role_policy_document {
object
.key("AssumeRolePolicyDocument")
.string(var_1516.as_str());
}
if let Some(var_1517) = &input.attached_managed_policies {
let mut array_1518 = object.key("AttachedManagedPolicies").start_array();
for item_1519 in var_1517 {
{
#[allow(unused_mut)]
let mut object_1520 = array_1518.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_iam_attached_managed_policy(
&mut object_1520,
item_1519,
)?;
object_1520.finish();
}
}
array_1518.finish();
}
if let Some(var_1521) = &input.create_date {
object.key("CreateDate").string(var_1521.as_str());
}
if let Some(var_1522) = &input.instance_profile_list {
let mut array_1523 = object.key("InstanceProfileList").start_array();
for item_1524 in var_1522 {
{
#[allow(unused_mut)]
let mut object_1525 = array_1523.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_iam_instance_profile(
&mut object_1525,
item_1524,
)?;
object_1525.finish();
}
}
array_1523.finish();
}
if let Some(var_1526) = &input.permissions_boundary {
#[allow(unused_mut)]
let mut object_1527 = object.key("PermissionsBoundary").start_object();
crate::json_ser::serialize_structure_crate_model_aws_iam_permissions_boundary(
&mut object_1527,
var_1526,
)?;
object_1527.finish();
}
if let Some(var_1528) = &input.role_id {
object.key("RoleId").string(var_1528.as_str());
}
if let Some(var_1529) = &input.role_name {
object.key("RoleName").string(var_1529.as_str());
}
if let Some(var_1530) = &input.role_policy_list {
let mut array_1531 = object.key("RolePolicyList").start_array();
for item_1532 in var_1530 {
{
#[allow(unused_mut)]
let mut object_1533 = array_1531.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_iam_role_policy(
&mut object_1533,
item_1532,
)?;
object_1533.finish();
}
}
array_1531.finish();
}
if input.max_session_duration != 0 {
object.key("MaxSessionDuration").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_session_duration).into()),
);
}
if let Some(var_1534) = &input.path {
object.key("Path").string(var_1534.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_kms_key_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsKmsKeyDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1535) = &input.aws_account_id {
object.key("AWSAccountId").string(var_1535.as_str());
}
if input.creation_date != 0.0 {
object.key("CreationDate").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.creation_date).into()),
);
}
if let Some(var_1536) = &input.key_id {
object.key("KeyId").string(var_1536.as_str());
}
if let Some(var_1537) = &input.key_manager {
object.key("KeyManager").string(var_1537.as_str());
}
if let Some(var_1538) = &input.key_state {
object.key("KeyState").string(var_1538.as_str());
}
if let Some(var_1539) = &input.origin {
object.key("Origin").string(var_1539.as_str());
}
if let Some(var_1540) = &input.description {
object.key("Description").string(var_1540.as_str());
}
if input.key_rotation_status {
object
.key("KeyRotationStatus")
.boolean(input.key_rotation_status);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_lambda_function_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsLambdaFunctionDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1541) = &input.code {
#[allow(unused_mut)]
let mut object_1542 = object.key("Code").start_object();
crate::json_ser::serialize_structure_crate_model_aws_lambda_function_code(
&mut object_1542,
var_1541,
)?;
object_1542.finish();
}
if let Some(var_1543) = &input.code_sha256 {
object.key("CodeSha256").string(var_1543.as_str());
}
if let Some(var_1544) = &input.dead_letter_config {
#[allow(unused_mut)]
let mut object_1545 = object.key("DeadLetterConfig").start_object();
crate::json_ser::serialize_structure_crate_model_aws_lambda_function_dead_letter_config(
&mut object_1545,
var_1544,
)?;
object_1545.finish();
}
if let Some(var_1546) = &input.environment {
#[allow(unused_mut)]
let mut object_1547 = object.key("Environment").start_object();
crate::json_ser::serialize_structure_crate_model_aws_lambda_function_environment(
&mut object_1547,
var_1546,
)?;
object_1547.finish();
}
if let Some(var_1548) = &input.function_name {
object.key("FunctionName").string(var_1548.as_str());
}
if let Some(var_1549) = &input.handler {
object.key("Handler").string(var_1549.as_str());
}
if let Some(var_1550) = &input.kms_key_arn {
object.key("KmsKeyArn").string(var_1550.as_str());
}
if let Some(var_1551) = &input.last_modified {
object.key("LastModified").string(var_1551.as_str());
}
if let Some(var_1552) = &input.layers {
let mut array_1553 = object.key("Layers").start_array();
for item_1554 in var_1552 {
{
#[allow(unused_mut)]
let mut object_1555 = array_1553.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_lambda_function_layer(
&mut object_1555,
item_1554,
)?;
object_1555.finish();
}
}
array_1553.finish();
}
if let Some(var_1556) = &input.master_arn {
object.key("MasterArn").string(var_1556.as_str());
}
if input.memory_size != 0 {
object.key("MemorySize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.memory_size).into()),
);
}
if let Some(var_1557) = &input.revision_id {
object.key("RevisionId").string(var_1557.as_str());
}
if let Some(var_1558) = &input.role {
object.key("Role").string(var_1558.as_str());
}
if let Some(var_1559) = &input.runtime {
object.key("Runtime").string(var_1559.as_str());
}
if input.timeout != 0 {
object.key("Timeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.timeout).into()),
);
}
if let Some(var_1560) = &input.tracing_config {
#[allow(unused_mut)]
let mut object_1561 = object.key("TracingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_aws_lambda_function_tracing_config(
&mut object_1561,
var_1560,
)?;
object_1561.finish();
}
if let Some(var_1562) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_1563 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_aws_lambda_function_vpc_config(
&mut object_1563,
var_1562,
)?;
object_1563.finish();
}
if let Some(var_1564) = &input.version {
object.key("Version").string(var_1564.as_str());
}
if let Some(var_1565) = &input.architectures {
let mut array_1566 = object.key("Architectures").start_array();
for item_1567 in var_1565 {
{
array_1566.value().string(item_1567.as_str());
}
}
array_1566.finish();
}
if let Some(var_1568) = &input.package_type {
object.key("PackageType").string(var_1568.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_lambda_layer_version_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsLambdaLayerVersionDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.version != 0 {
object.key("Version").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.version).into()),
);
}
if let Some(var_1569) = &input.compatible_runtimes {
let mut array_1570 = object.key("CompatibleRuntimes").start_array();
for item_1571 in var_1569 {
{
array_1570.value().string(item_1571.as_str());
}
}
array_1570.finish();
}
if let Some(var_1572) = &input.created_date {
object.key("CreatedDate").string(var_1572.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_rds_db_instance_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRdsDbInstanceDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1573) = &input.associated_roles {
let mut array_1574 = object.key("AssociatedRoles").start_array();
for item_1575 in var_1573 {
{
#[allow(unused_mut)]
let mut object_1576 = array_1574.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_instance_associated_role(&mut object_1576, item_1575)?;
object_1576.finish();
}
}
array_1574.finish();
}
if let Some(var_1577) = &input.ca_certificate_identifier {
object
.key("CACertificateIdentifier")
.string(var_1577.as_str());
}
if let Some(var_1578) = &input.db_cluster_identifier {
object.key("DBClusterIdentifier").string(var_1578.as_str());
}
if let Some(var_1579) = &input.db_instance_identifier {
object.key("DBInstanceIdentifier").string(var_1579.as_str());
}
if let Some(var_1580) = &input.db_instance_class {
object.key("DBInstanceClass").string(var_1580.as_str());
}
if input.db_instance_port != 0 {
object.key("DbInstancePort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.db_instance_port).into()),
);
}
if let Some(var_1581) = &input.dbi_resource_id {
object.key("DbiResourceId").string(var_1581.as_str());
}
if let Some(var_1582) = &input.db_name {
object.key("DBName").string(var_1582.as_str());
}
if input.deletion_protection {
object
.key("DeletionProtection")
.boolean(input.deletion_protection);
}
if let Some(var_1583) = &input.endpoint {
#[allow(unused_mut)]
let mut object_1584 = object.key("Endpoint").start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_instance_endpoint(
&mut object_1584,
var_1583,
)?;
object_1584.finish();
}
if let Some(var_1585) = &input.engine {
object.key("Engine").string(var_1585.as_str());
}
if let Some(var_1586) = &input.engine_version {
object.key("EngineVersion").string(var_1586.as_str());
}
if input.iam_database_authentication_enabled {
object
.key("IAMDatabaseAuthenticationEnabled")
.boolean(input.iam_database_authentication_enabled);
}
if let Some(var_1587) = &input.instance_create_time {
object.key("InstanceCreateTime").string(var_1587.as_str());
}
if let Some(var_1588) = &input.kms_key_id {
object.key("KmsKeyId").string(var_1588.as_str());
}
if input.publicly_accessible {
object
.key("PubliclyAccessible")
.boolean(input.publicly_accessible);
}
if input.storage_encrypted {
object
.key("StorageEncrypted")
.boolean(input.storage_encrypted);
}
if let Some(var_1589) = &input.tde_credential_arn {
object.key("TdeCredentialArn").string(var_1589.as_str());
}
if let Some(var_1590) = &input.vpc_security_groups {
let mut array_1591 = object.key("VpcSecurityGroups").start_array();
for item_1592 in var_1590 {
{
#[allow(unused_mut)]
let mut object_1593 = array_1591.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_instance_vpc_security_group(&mut object_1593, item_1592)?;
object_1593.finish();
}
}
array_1591.finish();
}
if input.multi_az {
object.key("MultiAz").boolean(input.multi_az);
}
if let Some(var_1594) = &input.enhanced_monitoring_resource_arn {
object
.key("EnhancedMonitoringResourceArn")
.string(var_1594.as_str());
}
if let Some(var_1595) = &input.db_instance_status {
object.key("DbInstanceStatus").string(var_1595.as_str());
}
if let Some(var_1596) = &input.master_username {
object.key("MasterUsername").string(var_1596.as_str());
}
if input.allocated_storage != 0 {
object.key("AllocatedStorage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.allocated_storage).into()),
);
}
if let Some(var_1597) = &input.preferred_backup_window {
object
.key("PreferredBackupWindow")
.string(var_1597.as_str());
}
if input.backup_retention_period != 0 {
object.key("BackupRetentionPeriod").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.backup_retention_period).into()),
);
}
if let Some(var_1598) = &input.db_security_groups {
let mut array_1599 = object.key("DbSecurityGroups").start_array();
for item_1600 in var_1598 {
{
array_1599.value().string(item_1600.as_str());
}
}
array_1599.finish();
}
if let Some(var_1601) = &input.db_parameter_groups {
let mut array_1602 = object.key("DbParameterGroups").start_array();
for item_1603 in var_1601 {
{
#[allow(unused_mut)]
let mut object_1604 = array_1602.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_parameter_group(
&mut object_1604,
item_1603,
)?;
object_1604.finish();
}
}
array_1602.finish();
}
if let Some(var_1605) = &input.availability_zone {
object.key("AvailabilityZone").string(var_1605.as_str());
}
if let Some(var_1606) = &input.db_subnet_group {
#[allow(unused_mut)]
let mut object_1607 = object.key("DbSubnetGroup").start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_subnet_group(
&mut object_1607,
var_1606,
)?;
object_1607.finish();
}
if let Some(var_1608) = &input.preferred_maintenance_window {
object
.key("PreferredMaintenanceWindow")
.string(var_1608.as_str());
}
if let Some(var_1609) = &input.pending_modified_values {
#[allow(unused_mut)]
let mut object_1610 = object.key("PendingModifiedValues").start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_pending_modified_values(
&mut object_1610,
var_1609,
)?;
object_1610.finish();
}
if let Some(var_1611) = &input.latest_restorable_time {
object.key("LatestRestorableTime").string(var_1611.as_str());
}
if input.auto_minor_version_upgrade {
object
.key("AutoMinorVersionUpgrade")
.boolean(input.auto_minor_version_upgrade);
}
if let Some(var_1612) = &input.read_replica_source_db_instance_identifier {
object
.key("ReadReplicaSourceDBInstanceIdentifier")
.string(var_1612.as_str());
}
if let Some(var_1613) = &input.read_replica_db_instance_identifiers {
let mut array_1614 = object.key("ReadReplicaDBInstanceIdentifiers").start_array();
for item_1615 in var_1613 {
{
array_1614.value().string(item_1615.as_str());
}
}
array_1614.finish();
}
if let Some(var_1616) = &input.read_replica_db_cluster_identifiers {
let mut array_1617 = object.key("ReadReplicaDBClusterIdentifiers").start_array();
for item_1618 in var_1616 {
{
array_1617.value().string(item_1618.as_str());
}
}
array_1617.finish();
}
if let Some(var_1619) = &input.license_model {
object.key("LicenseModel").string(var_1619.as_str());
}
if input.iops != 0 {
object.key("Iops").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.iops).into()),
);
}
if let Some(var_1620) = &input.option_group_memberships {
let mut array_1621 = object.key("OptionGroupMemberships").start_array();
for item_1622 in var_1620 {
{
#[allow(unused_mut)]
let mut object_1623 = array_1621.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_option_group_membership(&mut object_1623, item_1622)?;
object_1623.finish();
}
}
array_1621.finish();
}
if let Some(var_1624) = &input.character_set_name {
object.key("CharacterSetName").string(var_1624.as_str());
}
if let Some(var_1625) = &input.secondary_availability_zone {
object
.key("SecondaryAvailabilityZone")
.string(var_1625.as_str());
}
if let Some(var_1626) = &input.status_infos {
let mut array_1627 = object.key("StatusInfos").start_array();
for item_1628 in var_1626 {
{
#[allow(unused_mut)]
let mut object_1629 = array_1627.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_status_info(
&mut object_1629,
item_1628,
)?;
object_1629.finish();
}
}
array_1627.finish();
}
if let Some(var_1630) = &input.storage_type {
object.key("StorageType").string(var_1630.as_str());
}
if let Some(var_1631) = &input.domain_memberships {
let mut array_1632 = object.key("DomainMemberships").start_array();
for item_1633 in var_1631 {
{
#[allow(unused_mut)]
let mut object_1634 = array_1632.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_domain_membership(
&mut object_1634,
item_1633,
)?;
object_1634.finish();
}
}
array_1632.finish();
}
if input.copy_tags_to_snapshot {
object
.key("CopyTagsToSnapshot")
.boolean(input.copy_tags_to_snapshot);
}
if input.monitoring_interval != 0 {
object.key("MonitoringInterval").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.monitoring_interval).into()),
);
}
if let Some(var_1635) = &input.monitoring_role_arn {
object.key("MonitoringRoleArn").string(var_1635.as_str());
}
if input.promotion_tier != 0 {
object.key("PromotionTier").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.promotion_tier).into()),
);
}
if let Some(var_1636) = &input.timezone {
object.key("Timezone").string(var_1636.as_str());
}
if input.performance_insights_enabled {
object
.key("PerformanceInsightsEnabled")
.boolean(input.performance_insights_enabled);
}
if let Some(var_1637) = &input.performance_insights_kms_key_id {
object
.key("PerformanceInsightsKmsKeyId")
.string(var_1637.as_str());
}
if input.performance_insights_retention_period != 0 {
object.key("PerformanceInsightsRetentionPeriod").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.performance_insights_retention_period).into()),
);
}
if let Some(var_1638) = &input.enabled_cloud_watch_logs_exports {
let mut array_1639 = object.key("EnabledCloudWatchLogsExports").start_array();
for item_1640 in var_1638 {
{
array_1639.value().string(item_1640.as_str());
}
}
array_1639.finish();
}
if let Some(var_1641) = &input.processor_features {
let mut array_1642 = object.key("ProcessorFeatures").start_array();
for item_1643 in var_1641 {
{
#[allow(unused_mut)]
let mut object_1644 = array_1642.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_processor_feature(
&mut object_1644,
item_1643,
)?;
object_1644.finish();
}
}
array_1642.finish();
}
if let Some(var_1645) = &input.listener_endpoint {
#[allow(unused_mut)]
let mut object_1646 = object.key("ListenerEndpoint").start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_instance_endpoint(
&mut object_1646,
var_1645,
)?;
object_1646.finish();
}
if input.max_allocated_storage != 0 {
object.key("MaxAllocatedStorage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_allocated_storage).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_sns_topic_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsSnsTopicDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1647) = &input.kms_master_key_id {
object.key("KmsMasterKeyId").string(var_1647.as_str());
}
if let Some(var_1648) = &input.subscription {
let mut array_1649 = object.key("Subscription").start_array();
for item_1650 in var_1648 {
{
#[allow(unused_mut)]
let mut object_1651 = array_1649.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_sns_topic_subscription(
&mut object_1651,
item_1650,
)?;
object_1651.finish();
}
}
array_1649.finish();
}
if let Some(var_1652) = &input.topic_name {
object.key("TopicName").string(var_1652.as_str());
}
if let Some(var_1653) = &input.owner {
object.key("Owner").string(var_1653.as_str());
}
if let Some(var_1654) = &input.sqs_success_feedback_role_arn {
object
.key("SqsSuccessFeedbackRoleArn")
.string(var_1654.as_str());
}
if let Some(var_1655) = &input.sqs_failure_feedback_role_arn {
object
.key("SqsFailureFeedbackRoleArn")
.string(var_1655.as_str());
}
if let Some(var_1656) = &input.application_success_feedback_role_arn {
object
.key("ApplicationSuccessFeedbackRoleArn")
.string(var_1656.as_str());
}
if let Some(var_1657) = &input.firehose_success_feedback_role_arn {
object
.key("FirehoseSuccessFeedbackRoleArn")
.string(var_1657.as_str());
}
if let Some(var_1658) = &input.firehose_failure_feedback_role_arn {
object
.key("FirehoseFailureFeedbackRoleArn")
.string(var_1658.as_str());
}
if let Some(var_1659) = &input.http_success_feedback_role_arn {
object
.key("HttpSuccessFeedbackRoleArn")
.string(var_1659.as_str());
}
if let Some(var_1660) = &input.http_failure_feedback_role_arn {
object
.key("HttpFailureFeedbackRoleArn")
.string(var_1660.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_sqs_queue_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsSqsQueueDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.kms_data_key_reuse_period_seconds != 0 {
object.key("KmsDataKeyReusePeriodSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.kms_data_key_reuse_period_seconds).into()),
);
}
if let Some(var_1661) = &input.kms_master_key_id {
object.key("KmsMasterKeyId").string(var_1661.as_str());
}
if let Some(var_1662) = &input.queue_name {
object.key("QueueName").string(var_1662.as_str());
}
if let Some(var_1663) = &input.dead_letter_target_arn {
object.key("DeadLetterTargetArn").string(var_1663.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_waf_web_acl_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafWebAclDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1664) = &input.name {
object.key("Name").string(var_1664.as_str());
}
if let Some(var_1665) = &input.default_action {
object.key("DefaultAction").string(var_1665.as_str());
}
if let Some(var_1666) = &input.rules {
let mut array_1667 = object.key("Rules").start_array();
for item_1668 in var_1666 {
{
#[allow(unused_mut)]
let mut object_1669 = array_1667.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_waf_web_acl_rule(
&mut object_1669,
item_1668,
)?;
object_1669.finish();
}
}
array_1667.finish();
}
if let Some(var_1670) = &input.web_acl_id {
object.key("WebAclId").string(var_1670.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_rds_db_snapshot_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRdsDbSnapshotDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1671) = &input.db_snapshot_identifier {
object.key("DbSnapshotIdentifier").string(var_1671.as_str());
}
if let Some(var_1672) = &input.db_instance_identifier {
object.key("DbInstanceIdentifier").string(var_1672.as_str());
}
if let Some(var_1673) = &input.snapshot_create_time {
object.key("SnapshotCreateTime").string(var_1673.as_str());
}
if let Some(var_1674) = &input.engine {
object.key("Engine").string(var_1674.as_str());
}
if input.allocated_storage != 0 {
object.key("AllocatedStorage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.allocated_storage).into()),
);
}
if let Some(var_1675) = &input.status {
object.key("Status").string(var_1675.as_str());
}
if input.port != 0 {
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port).into()),
);
}
if let Some(var_1676) = &input.availability_zone {
object.key("AvailabilityZone").string(var_1676.as_str());
}
if let Some(var_1677) = &input.vpc_id {
object.key("VpcId").string(var_1677.as_str());
}
if let Some(var_1678) = &input.instance_create_time {
object.key("InstanceCreateTime").string(var_1678.as_str());
}
if let Some(var_1679) = &input.master_username {
object.key("MasterUsername").string(var_1679.as_str());
}
if let Some(var_1680) = &input.engine_version {
object.key("EngineVersion").string(var_1680.as_str());
}
if let Some(var_1681) = &input.license_model {
object.key("LicenseModel").string(var_1681.as_str());
}
if let Some(var_1682) = &input.snapshot_type {
object.key("SnapshotType").string(var_1682.as_str());
}
if input.iops != 0 {
object.key("Iops").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.iops).into()),
);
}
if let Some(var_1683) = &input.option_group_name {
object.key("OptionGroupName").string(var_1683.as_str());
}
if input.percent_progress != 0 {
object.key("PercentProgress").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.percent_progress).into()),
);
}
if let Some(var_1684) = &input.source_region {
object.key("SourceRegion").string(var_1684.as_str());
}
if let Some(var_1685) = &input.source_db_snapshot_identifier {
object
.key("SourceDbSnapshotIdentifier")
.string(var_1685.as_str());
}
if let Some(var_1686) = &input.storage_type {
object.key("StorageType").string(var_1686.as_str());
}
if let Some(var_1687) = &input.tde_credential_arn {
object.key("TdeCredentialArn").string(var_1687.as_str());
}
if input.encrypted {
object.key("Encrypted").boolean(input.encrypted);
}
if let Some(var_1688) = &input.kms_key_id {
object.key("KmsKeyId").string(var_1688.as_str());
}
if let Some(var_1689) = &input.timezone {
object.key("Timezone").string(var_1689.as_str());
}
if input.iam_database_authentication_enabled {
object
.key("IamDatabaseAuthenticationEnabled")
.boolean(input.iam_database_authentication_enabled);
}
if let Some(var_1690) = &input.processor_features {
let mut array_1691 = object.key("ProcessorFeatures").start_array();
for item_1692 in var_1690 {
{
#[allow(unused_mut)]
let mut object_1693 = array_1691.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_processor_feature(
&mut object_1693,
item_1692,
)?;
object_1693.finish();
}
}
array_1691.finish();
}
if let Some(var_1694) = &input.dbi_resource_id {
object.key("DbiResourceId").string(var_1694.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_rds_db_cluster_snapshot_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRdsDbClusterSnapshotDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1695) = &input.availability_zones {
let mut array_1696 = object.key("AvailabilityZones").start_array();
for item_1697 in var_1695 {
{
array_1696.value().string(item_1697.as_str());
}
}
array_1696.finish();
}
if let Some(var_1698) = &input.snapshot_create_time {
object.key("SnapshotCreateTime").string(var_1698.as_str());
}
if let Some(var_1699) = &input.engine {
object.key("Engine").string(var_1699.as_str());
}
if input.allocated_storage != 0 {
object.key("AllocatedStorage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.allocated_storage).into()),
);
}
if let Some(var_1700) = &input.status {
object.key("Status").string(var_1700.as_str());
}
if input.port != 0 {
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port).into()),
);
}
if let Some(var_1701) = &input.vpc_id {
object.key("VpcId").string(var_1701.as_str());
}
if let Some(var_1702) = &input.cluster_create_time {
object.key("ClusterCreateTime").string(var_1702.as_str());
}
if let Some(var_1703) = &input.master_username {
object.key("MasterUsername").string(var_1703.as_str());
}
if let Some(var_1704) = &input.engine_version {
object.key("EngineVersion").string(var_1704.as_str());
}
if let Some(var_1705) = &input.license_model {
object.key("LicenseModel").string(var_1705.as_str());
}
if let Some(var_1706) = &input.snapshot_type {
object.key("SnapshotType").string(var_1706.as_str());
}
if input.percent_progress != 0 {
object.key("PercentProgress").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.percent_progress).into()),
);
}
if input.storage_encrypted {
object
.key("StorageEncrypted")
.boolean(input.storage_encrypted);
}
if let Some(var_1707) = &input.kms_key_id {
object.key("KmsKeyId").string(var_1707.as_str());
}
if let Some(var_1708) = &input.db_cluster_identifier {
object.key("DbClusterIdentifier").string(var_1708.as_str());
}
if let Some(var_1709) = &input.db_cluster_snapshot_identifier {
object
.key("DbClusterSnapshotIdentifier")
.string(var_1709.as_str());
}
if input.iam_database_authentication_enabled {
object
.key("IamDatabaseAuthenticationEnabled")
.boolean(input.iam_database_authentication_enabled);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_rds_db_cluster_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRdsDbClusterDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.allocated_storage != 0 {
object.key("AllocatedStorage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.allocated_storage).into()),
);
}
if let Some(var_1710) = &input.availability_zones {
let mut array_1711 = object.key("AvailabilityZones").start_array();
for item_1712 in var_1710 {
{
array_1711.value().string(item_1712.as_str());
}
}
array_1711.finish();
}
if input.backup_retention_period != 0 {
object.key("BackupRetentionPeriod").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.backup_retention_period).into()),
);
}
if let Some(var_1713) = &input.database_name {
object.key("DatabaseName").string(var_1713.as_str());
}
if let Some(var_1714) = &input.status {
object.key("Status").string(var_1714.as_str());
}
if let Some(var_1715) = &input.endpoint {
object.key("Endpoint").string(var_1715.as_str());
}
if let Some(var_1716) = &input.reader_endpoint {
object.key("ReaderEndpoint").string(var_1716.as_str());
}
if let Some(var_1717) = &input.custom_endpoints {
let mut array_1718 = object.key("CustomEndpoints").start_array();
for item_1719 in var_1717 {
{
array_1718.value().string(item_1719.as_str());
}
}
array_1718.finish();
}
if input.multi_az {
object.key("MultiAz").boolean(input.multi_az);
}
if let Some(var_1720) = &input.engine {
object.key("Engine").string(var_1720.as_str());
}
if let Some(var_1721) = &input.engine_version {
object.key("EngineVersion").string(var_1721.as_str());
}
if input.port != 0 {
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port).into()),
);
}
if let Some(var_1722) = &input.master_username {
object.key("MasterUsername").string(var_1722.as_str());
}
if let Some(var_1723) = &input.preferred_backup_window {
object
.key("PreferredBackupWindow")
.string(var_1723.as_str());
}
if let Some(var_1724) = &input.preferred_maintenance_window {
object
.key("PreferredMaintenanceWindow")
.string(var_1724.as_str());
}
if let Some(var_1725) = &input.read_replica_identifiers {
let mut array_1726 = object.key("ReadReplicaIdentifiers").start_array();
for item_1727 in var_1725 {
{
array_1726.value().string(item_1727.as_str());
}
}
array_1726.finish();
}
if let Some(var_1728) = &input.vpc_security_groups {
let mut array_1729 = object.key("VpcSecurityGroups").start_array();
for item_1730 in var_1728 {
{
#[allow(unused_mut)]
let mut object_1731 = array_1729.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_instance_vpc_security_group(&mut object_1731, item_1730)?;
object_1731.finish();
}
}
array_1729.finish();
}
if let Some(var_1732) = &input.hosted_zone_id {
object.key("HostedZoneId").string(var_1732.as_str());
}
if input.storage_encrypted {
object
.key("StorageEncrypted")
.boolean(input.storage_encrypted);
}
if let Some(var_1733) = &input.kms_key_id {
object.key("KmsKeyId").string(var_1733.as_str());
}
if let Some(var_1734) = &input.db_cluster_resource_id {
object.key("DbClusterResourceId").string(var_1734.as_str());
}
if let Some(var_1735) = &input.associated_roles {
let mut array_1736 = object.key("AssociatedRoles").start_array();
for item_1737 in var_1735 {
{
#[allow(unused_mut)]
let mut object_1738 = array_1736.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_cluster_associated_role(&mut object_1738, item_1737)?;
object_1738.finish();
}
}
array_1736.finish();
}
if let Some(var_1739) = &input.cluster_create_time {
object.key("ClusterCreateTime").string(var_1739.as_str());
}
if let Some(var_1740) = &input.enabled_cloud_watch_logs_exports {
let mut array_1741 = object.key("EnabledCloudWatchLogsExports").start_array();
for item_1742 in var_1740 {
{
array_1741.value().string(item_1742.as_str());
}
}
array_1741.finish();
}
if let Some(var_1743) = &input.engine_mode {
object.key("EngineMode").string(var_1743.as_str());
}
if input.deletion_protection {
object
.key("DeletionProtection")
.boolean(input.deletion_protection);
}
if input.http_endpoint_enabled {
object
.key("HttpEndpointEnabled")
.boolean(input.http_endpoint_enabled);
}
if let Some(var_1744) = &input.activity_stream_status {
object.key("ActivityStreamStatus").string(var_1744.as_str());
}
if input.copy_tags_to_snapshot {
object
.key("CopyTagsToSnapshot")
.boolean(input.copy_tags_to_snapshot);
}
if input.cross_account_clone {
object
.key("CrossAccountClone")
.boolean(input.cross_account_clone);
}
if let Some(var_1745) = &input.domain_memberships {
let mut array_1746 = object.key("DomainMemberships").start_array();
for item_1747 in var_1745 {
{
#[allow(unused_mut)]
let mut object_1748 = array_1746.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_domain_membership(
&mut object_1748,
item_1747,
)?;
object_1748.finish();
}
}
array_1746.finish();
}
if let Some(var_1749) = &input.db_cluster_parameter_group {
object
.key("DbClusterParameterGroup")
.string(var_1749.as_str());
}
if let Some(var_1750) = &input.db_subnet_group {
object.key("DbSubnetGroup").string(var_1750.as_str());
}
if let Some(var_1751) = &input.db_cluster_option_group_memberships {
let mut array_1752 = object.key("DbClusterOptionGroupMemberships").start_array();
for item_1753 in var_1751 {
{
#[allow(unused_mut)]
let mut object_1754 = array_1752.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_cluster_option_group_membership(&mut object_1754, item_1753)?;
object_1754.finish();
}
}
array_1752.finish();
}
if let Some(var_1755) = &input.db_cluster_identifier {
object.key("DbClusterIdentifier").string(var_1755.as_str());
}
if let Some(var_1756) = &input.db_cluster_members {
let mut array_1757 = object.key("DbClusterMembers").start_array();
for item_1758 in var_1756 {
{
#[allow(unused_mut)]
let mut object_1759 = array_1757.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_cluster_member(
&mut object_1759,
item_1758,
)?;
object_1759.finish();
}
}
array_1757.finish();
}
if input.iam_database_authentication_enabled {
object
.key("IamDatabaseAuthenticationEnabled")
.boolean(input.iam_database_authentication_enabled);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_cluster_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsClusterDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1760) = &input.cluster_arn {
object.key("ClusterArn").string(var_1760.as_str());
}
if input.active_services_count != 0 {
object.key("ActiveServicesCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.active_services_count).into()),
);
}
if let Some(var_1761) = &input.capacity_providers {
let mut array_1762 = object.key("CapacityProviders").start_array();
for item_1763 in var_1761 {
{
array_1762.value().string(item_1763.as_str());
}
}
array_1762.finish();
}
if let Some(var_1764) = &input.cluster_settings {
let mut array_1765 = object.key("ClusterSettings").start_array();
for item_1766 in var_1764 {
{
#[allow(unused_mut)]
let mut object_1767 = array_1765.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_cluster_cluster_settings_details(&mut object_1767, item_1766)?;
object_1767.finish();
}
}
array_1765.finish();
}
if let Some(var_1768) = &input.configuration {
#[allow(unused_mut)]
let mut object_1769 = object.key("Configuration").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_cluster_configuration_details(
&mut object_1769,
var_1768,
)?;
object_1769.finish();
}
if let Some(var_1770) = &input.default_capacity_provider_strategy {
let mut array_1771 = object.key("DefaultCapacityProviderStrategy").start_array();
for item_1772 in var_1770 {
{
#[allow(unused_mut)]
let mut object_1773 = array_1771.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_cluster_default_capacity_provider_strategy_details(&mut object_1773, item_1772)?;
object_1773.finish();
}
}
array_1771.finish();
}
if let Some(var_1774) = &input.cluster_name {
object.key("ClusterName").string(var_1774.as_str());
}
if input.registered_container_instances_count != 0 {
object.key("RegisteredContainerInstancesCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.registered_container_instances_count).into()),
);
}
if input.running_tasks_count != 0 {
object.key("RunningTasksCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.running_tasks_count).into()),
);
}
if let Some(var_1775) = &input.status {
object.key("Status").string(var_1775.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_container_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsContainerDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1776) = &input.name {
object.key("Name").string(var_1776.as_str());
}
if let Some(var_1777) = &input.image {
object.key("Image").string(var_1777.as_str());
}
if let Some(var_1778) = &input.mount_points {
let mut array_1779 = object.key("MountPoints").start_array();
for item_1780 in var_1778 {
{
#[allow(unused_mut)]
let mut object_1781 = array_1779.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_mount_point(
&mut object_1781,
item_1780,
)?;
object_1781.finish();
}
}
array_1779.finish();
}
if input.privileged {
object.key("Privileged").boolean(input.privileged);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1782) = &input.container_definitions {
let mut array_1783 = object.key("ContainerDefinitions").start_array();
for item_1784 in var_1782 {
{
#[allow(unused_mut)]
let mut object_1785 = array_1783.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_details(&mut object_1785, item_1784)?;
object_1785.finish();
}
}
array_1783.finish();
}
if let Some(var_1786) = &input.cpu {
object.key("Cpu").string(var_1786.as_str());
}
if let Some(var_1787) = &input.execution_role_arn {
object.key("ExecutionRoleArn").string(var_1787.as_str());
}
if let Some(var_1788) = &input.family {
object.key("Family").string(var_1788.as_str());
}
if let Some(var_1789) = &input.inference_accelerators {
let mut array_1790 = object.key("InferenceAccelerators").start_array();
for item_1791 in var_1789 {
{
#[allow(unused_mut)]
let mut object_1792 = array_1790.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_inference_accelerators_details(&mut object_1792, item_1791)?;
object_1792.finish();
}
}
array_1790.finish();
}
if let Some(var_1793) = &input.ipc_mode {
object.key("IpcMode").string(var_1793.as_str());
}
if let Some(var_1794) = &input.memory {
object.key("Memory").string(var_1794.as_str());
}
if let Some(var_1795) = &input.network_mode {
object.key("NetworkMode").string(var_1795.as_str());
}
if let Some(var_1796) = &input.pid_mode {
object.key("PidMode").string(var_1796.as_str());
}
if let Some(var_1797) = &input.placement_constraints {
let mut array_1798 = object.key("PlacementConstraints").start_array();
for item_1799 in var_1797 {
{
#[allow(unused_mut)]
let mut object_1800 = array_1798.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_placement_constraints_details(&mut object_1800, item_1799)?;
object_1800.finish();
}
}
array_1798.finish();
}
if let Some(var_1801) = &input.proxy_configuration {
#[allow(unused_mut)]
let mut object_1802 = object.key("ProxyConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_proxy_configuration_details(&mut object_1802, var_1801)?;
object_1802.finish();
}
if let Some(var_1803) = &input.requires_compatibilities {
let mut array_1804 = object.key("RequiresCompatibilities").start_array();
for item_1805 in var_1803 {
{
array_1804.value().string(item_1805.as_str());
}
}
array_1804.finish();
}
if let Some(var_1806) = &input.task_role_arn {
object.key("TaskRoleArn").string(var_1806.as_str());
}
if let Some(var_1807) = &input.volumes {
let mut array_1808 = object.key("Volumes").start_array();
for item_1809 in var_1807 {
{
#[allow(unused_mut)]
let mut object_1810 = array_1808.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_volumes_details(&mut object_1810, item_1809)?;
object_1810.finish();
}
}
array_1808.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_container_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ContainerDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1811) = &input.container_runtime {
object.key("ContainerRuntime").string(var_1811.as_str());
}
if let Some(var_1812) = &input.name {
object.key("Name").string(var_1812.as_str());
}
if let Some(var_1813) = &input.image_id {
object.key("ImageId").string(var_1813.as_str());
}
if let Some(var_1814) = &input.image_name {
object.key("ImageName").string(var_1814.as_str());
}
if let Some(var_1815) = &input.launched_at {
object.key("LaunchedAt").string(var_1815.as_str());
}
if let Some(var_1816) = &input.volume_mounts {
let mut array_1817 = object.key("VolumeMounts").start_array();
for item_1818 in var_1816 {
{
#[allow(unused_mut)]
let mut object_1819 = array_1817.value().start_object();
crate::json_ser::serialize_structure_crate_model_volume_mount(
&mut object_1819,
item_1818,
)?;
object_1819.finish();
}
}
array_1817.finish();
}
if input.privileged {
object.key("Privileged").boolean(input.privileged);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_rds_event_subscription_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRdsEventSubscriptionDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1820) = &input.cust_subscription_id {
object.key("CustSubscriptionId").string(var_1820.as_str());
}
if let Some(var_1821) = &input.customer_aws_id {
object.key("CustomerAwsId").string(var_1821.as_str());
}
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_1822) = &input.event_categories_list {
let mut array_1823 = object.key("EventCategoriesList").start_array();
for item_1824 in var_1822 {
{
array_1823.value().string(item_1824.as_str());
}
}
array_1823.finish();
}
if let Some(var_1825) = &input.event_subscription_arn {
object.key("EventSubscriptionArn").string(var_1825.as_str());
}
if let Some(var_1826) = &input.sns_topic_arn {
object.key("SnsTopicArn").string(var_1826.as_str());
}
if let Some(var_1827) = &input.source_ids_list {
let mut array_1828 = object.key("SourceIdsList").start_array();
for item_1829 in var_1827 {
{
array_1828.value().string(item_1829.as_str());
}
}
array_1828.finish();
}
if let Some(var_1830) = &input.source_type {
object.key("SourceType").string(var_1830.as_str());
}
if let Some(var_1831) = &input.status {
object.key("Status").string(var_1831.as_str());
}
if let Some(var_1832) = &input.subscription_creation_time {
object
.key("SubscriptionCreationTime")
.string(var_1832.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_service_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsServiceDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1833) = &input.capacity_provider_strategy {
let mut array_1834 = object.key("CapacityProviderStrategy").start_array();
for item_1835 in var_1833 {
{
#[allow(unused_mut)]
let mut object_1836 = array_1834.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_service_capacity_provider_strategy_details(&mut object_1836, item_1835)?;
object_1836.finish();
}
}
array_1834.finish();
}
if let Some(var_1837) = &input.cluster {
object.key("Cluster").string(var_1837.as_str());
}
if let Some(var_1838) = &input.deployment_configuration {
#[allow(unused_mut)]
let mut object_1839 = object.key("DeploymentConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_service_deployment_configuration_details(&mut object_1839, var_1838)?;
object_1839.finish();
}
if let Some(var_1840) = &input.deployment_controller {
#[allow(unused_mut)]
let mut object_1841 = object.key("DeploymentController").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_service_deployment_controller_details(&mut object_1841, var_1840)?;
object_1841.finish();
}
if input.desired_count != 0 {
object.key("DesiredCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.desired_count).into()),
);
}
if input.enable_ecs_managed_tags {
object
.key("EnableEcsManagedTags")
.boolean(input.enable_ecs_managed_tags);
}
if input.enable_execute_command {
object
.key("EnableExecuteCommand")
.boolean(input.enable_execute_command);
}
if input.health_check_grace_period_seconds != 0 {
object.key("HealthCheckGracePeriodSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.health_check_grace_period_seconds).into()),
);
}
if let Some(var_1842) = &input.launch_type {
object.key("LaunchType").string(var_1842.as_str());
}
if let Some(var_1843) = &input.load_balancers {
let mut array_1844 = object.key("LoadBalancers").start_array();
for item_1845 in var_1843 {
{
#[allow(unused_mut)]
let mut object_1846 = array_1844.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_service_load_balancers_details(&mut object_1846, item_1845)?;
object_1846.finish();
}
}
array_1844.finish();
}
if let Some(var_1847) = &input.name {
object.key("Name").string(var_1847.as_str());
}
if let Some(var_1848) = &input.network_configuration {
#[allow(unused_mut)]
let mut object_1849 = object.key("NetworkConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_service_network_configuration_details(&mut object_1849, var_1848)?;
object_1849.finish();
}
if let Some(var_1850) = &input.placement_constraints {
let mut array_1851 = object.key("PlacementConstraints").start_array();
for item_1852 in var_1850 {
{
#[allow(unused_mut)]
let mut object_1853 = array_1851.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_service_placement_constraints_details(&mut object_1853, item_1852)?;
object_1853.finish();
}
}
array_1851.finish();
}
if let Some(var_1854) = &input.placement_strategies {
let mut array_1855 = object.key("PlacementStrategies").start_array();
for item_1856 in var_1854 {
{
#[allow(unused_mut)]
let mut object_1857 = array_1855.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_service_placement_strategies_details(&mut object_1857, item_1856)?;
object_1857.finish();
}
}
array_1855.finish();
}
if let Some(var_1858) = &input.platform_version {
object.key("PlatformVersion").string(var_1858.as_str());
}
if let Some(var_1859) = &input.propagate_tags {
object.key("PropagateTags").string(var_1859.as_str());
}
if let Some(var_1860) = &input.role {
object.key("Role").string(var_1860.as_str());
}
if let Some(var_1861) = &input.scheduling_strategy {
object.key("SchedulingStrategy").string(var_1861.as_str());
}
if let Some(var_1862) = &input.service_arn {
object.key("ServiceArn").string(var_1862.as_str());
}
if let Some(var_1863) = &input.service_name {
object.key("ServiceName").string(var_1863.as_str());
}
if let Some(var_1864) = &input.service_registries {
let mut array_1865 = object.key("ServiceRegistries").start_array();
for item_1866 in var_1864 {
{
#[allow(unused_mut)]
let mut object_1867 = array_1865.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_service_service_registries_details(&mut object_1867, item_1866)?;
object_1867.finish();
}
}
array_1865.finish();
}
if let Some(var_1868) = &input.task_definition {
object.key("TaskDefinition").string(var_1868.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_auto_scaling_launch_configuration_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsAutoScalingLaunchConfigurationDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.associate_public_ip_address {
object
.key("AssociatePublicIpAddress")
.boolean(input.associate_public_ip_address);
}
if let Some(var_1869) = &input.block_device_mappings {
let mut array_1870 = object.key("BlockDeviceMappings").start_array();
for item_1871 in var_1869 {
{
#[allow(unused_mut)]
let mut object_1872 = array_1870.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_auto_scaling_launch_configuration_block_device_mappings_details(&mut object_1872, item_1871)?;
object_1872.finish();
}
}
array_1870.finish();
}
if let Some(var_1873) = &input.classic_link_vpc_id {
object.key("ClassicLinkVpcId").string(var_1873.as_str());
}
if let Some(var_1874) = &input.classic_link_vpc_security_groups {
let mut array_1875 = object.key("ClassicLinkVpcSecurityGroups").start_array();
for item_1876 in var_1874 {
{
array_1875.value().string(item_1876.as_str());
}
}
array_1875.finish();
}
if let Some(var_1877) = &input.created_time {
object.key("CreatedTime").string(var_1877.as_str());
}
if input.ebs_optimized {
object.key("EbsOptimized").boolean(input.ebs_optimized);
}
if let Some(var_1878) = &input.iam_instance_profile {
object.key("IamInstanceProfile").string(var_1878.as_str());
}
if let Some(var_1879) = &input.image_id {
object.key("ImageId").string(var_1879.as_str());
}
if let Some(var_1880) = &input.instance_monitoring {
#[allow(unused_mut)]
let mut object_1881 = object.key("InstanceMonitoring").start_object();
crate::json_ser::serialize_structure_crate_model_aws_auto_scaling_launch_configuration_instance_monitoring_details(&mut object_1881, var_1880)?;
object_1881.finish();
}
if let Some(var_1882) = &input.instance_type {
object.key("InstanceType").string(var_1882.as_str());
}
if let Some(var_1883) = &input.kernel_id {
object.key("KernelId").string(var_1883.as_str());
}
if let Some(var_1884) = &input.key_name {
object.key("KeyName").string(var_1884.as_str());
}
if let Some(var_1885) = &input.launch_configuration_name {
object
.key("LaunchConfigurationName")
.string(var_1885.as_str());
}
if let Some(var_1886) = &input.placement_tenancy {
object.key("PlacementTenancy").string(var_1886.as_str());
}
if let Some(var_1887) = &input.ramdisk_id {
object.key("RamdiskId").string(var_1887.as_str());
}
if let Some(var_1888) = &input.security_groups {
let mut array_1889 = object.key("SecurityGroups").start_array();
for item_1890 in var_1888 {
{
array_1889.value().string(item_1890.as_str());
}
}
array_1889.finish();
}
if let Some(var_1891) = &input.spot_price {
object.key("SpotPrice").string(var_1891.as_str());
}
if let Some(var_1892) = &input.user_data {
object.key("UserData").string(var_1892.as_str());
}
if let Some(var_1893) = &input.metadata_options {
#[allow(unused_mut)]
let mut object_1894 = object.key("MetadataOptions").start_object();
crate::json_ser::serialize_structure_crate_model_aws_auto_scaling_launch_configuration_metadata_options(&mut object_1894, var_1893)?;
object_1894.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_vpn_connection_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2VpnConnectionDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1895) = &input.vpn_connection_id {
object.key("VpnConnectionId").string(var_1895.as_str());
}
if let Some(var_1896) = &input.state {
object.key("State").string(var_1896.as_str());
}
if let Some(var_1897) = &input.customer_gateway_id {
object.key("CustomerGatewayId").string(var_1897.as_str());
}
if let Some(var_1898) = &input.customer_gateway_configuration {
object
.key("CustomerGatewayConfiguration")
.string(var_1898.as_str());
}
if let Some(var_1899) = &input.r#type {
object.key("Type").string(var_1899.as_str());
}
if let Some(var_1900) = &input.vpn_gateway_id {
object.key("VpnGatewayId").string(var_1900.as_str());
}
if let Some(var_1901) = &input.category {
object.key("Category").string(var_1901.as_str());
}
if let Some(var_1902) = &input.vgw_telemetry {
let mut array_1903 = object.key("VgwTelemetry").start_array();
for item_1904 in var_1902 {
{
#[allow(unused_mut)]
let mut object_1905 = array_1903.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_vpn_connection_vgw_telemetry_details(&mut object_1905, item_1904)?;
object_1905.finish();
}
}
array_1903.finish();
}
if let Some(var_1906) = &input.options {
#[allow(unused_mut)]
let mut object_1907 = object.key("Options").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_vpn_connection_options_details(
&mut object_1907,
var_1906,
)?;
object_1907.finish();
}
if let Some(var_1908) = &input.routes {
let mut array_1909 = object.key("Routes").start_array();
for item_1910 in var_1908 {
{
#[allow(unused_mut)]
let mut object_1911 = array_1909.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_vpn_connection_routes_details(&mut object_1911, item_1910)?;
object_1911.finish();
}
}
array_1909.finish();
}
if let Some(var_1912) = &input.transit_gateway_id {
object.key("TransitGatewayId").string(var_1912.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecr_container_image_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcrContainerImageDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1913) = &input.registry_id {
object.key("RegistryId").string(var_1913.as_str());
}
if let Some(var_1914) = &input.repository_name {
object.key("RepositoryName").string(var_1914.as_str());
}
if let Some(var_1915) = &input.architecture {
object.key("Architecture").string(var_1915.as_str());
}
if let Some(var_1916) = &input.image_digest {
object.key("ImageDigest").string(var_1916.as_str());
}
if let Some(var_1917) = &input.image_tags {
let mut array_1918 = object.key("ImageTags").start_array();
for item_1919 in var_1917 {
{
array_1918.value().string(item_1919.as_str());
}
}
array_1918.finish();
}
if let Some(var_1920) = &input.image_published_at {
object.key("ImagePublishedAt").string(var_1920.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_open_search_service_domain_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsOpenSearchServiceDomainDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1921) = &input.arn {
object.key("Arn").string(var_1921.as_str());
}
if let Some(var_1922) = &input.access_policies {
object.key("AccessPolicies").string(var_1922.as_str());
}
if let Some(var_1923) = &input.domain_name {
object.key("DomainName").string(var_1923.as_str());
}
if let Some(var_1924) = &input.id {
object.key("Id").string(var_1924.as_str());
}
if let Some(var_1925) = &input.domain_endpoint {
object.key("DomainEndpoint").string(var_1925.as_str());
}
if let Some(var_1926) = &input.engine_version {
object.key("EngineVersion").string(var_1926.as_str());
}
if let Some(var_1927) = &input.encryption_at_rest_options {
#[allow(unused_mut)]
let mut object_1928 = object.key("EncryptionAtRestOptions").start_object();
crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_encryption_at_rest_options_details(&mut object_1928, var_1927)?;
object_1928.finish();
}
if let Some(var_1929) = &input.node_to_node_encryption_options {
#[allow(unused_mut)]
let mut object_1930 = object.key("NodeToNodeEncryptionOptions").start_object();
crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_node_to_node_encryption_options_details(&mut object_1930, var_1929)?;
object_1930.finish();
}
if let Some(var_1931) = &input.service_software_options {
#[allow(unused_mut)]
let mut object_1932 = object.key("ServiceSoftwareOptions").start_object();
crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_service_software_options_details(&mut object_1932, var_1931)?;
object_1932.finish();
}
if let Some(var_1933) = &input.cluster_config {
#[allow(unused_mut)]
let mut object_1934 = object.key("ClusterConfig").start_object();
crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_cluster_config_details(&mut object_1934, var_1933)?;
object_1934.finish();
}
if let Some(var_1935) = &input.domain_endpoint_options {
#[allow(unused_mut)]
let mut object_1936 = object.key("DomainEndpointOptions").start_object();
crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_domain_endpoint_options_details(&mut object_1936, var_1935)?;
object_1936.finish();
}
if let Some(var_1937) = &input.vpc_options {
#[allow(unused_mut)]
let mut object_1938 = object.key("VpcOptions").start_object();
crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_vpc_options_details(&mut object_1938, var_1937)?;
object_1938.finish();
}
if let Some(var_1939) = &input.log_publishing_options {
#[allow(unused_mut)]
let mut object_1940 = object.key("LogPublishingOptions").start_object();
crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_log_publishing_options_details(&mut object_1940, var_1939)?;
object_1940.finish();
}
if let Some(var_1941) = &input.domain_endpoints {
#[allow(unused_mut)]
let mut object_1942 = object.key("DomainEndpoints").start_object();
for (key_1943, value_1944) in var_1941 {
{
object_1942
.key(key_1943.as_str())
.string(value_1944.as_str());
}
}
object_1942.finish();
}
if let Some(var_1945) = &input.advanced_security_options {
#[allow(unused_mut)]
let mut object_1946 = object.key("AdvancedSecurityOptions").start_object();
crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_advanced_security_options_details(&mut object_1946, var_1945)?;
object_1946.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_vpc_endpoint_service_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2VpcEndpointServiceDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.acceptance_required {
object
.key("AcceptanceRequired")
.boolean(input.acceptance_required);
}
if let Some(var_1947) = &input.availability_zones {
let mut array_1948 = object.key("AvailabilityZones").start_array();
for item_1949 in var_1947 {
{
array_1948.value().string(item_1949.as_str());
}
}
array_1948.finish();
}
if let Some(var_1950) = &input.base_endpoint_dns_names {
let mut array_1951 = object.key("BaseEndpointDnsNames").start_array();
for item_1952 in var_1950 {
{
array_1951.value().string(item_1952.as_str());
}
}
array_1951.finish();
}
if input.manages_vpc_endpoints {
object
.key("ManagesVpcEndpoints")
.boolean(input.manages_vpc_endpoints);
}
if let Some(var_1953) = &input.gateway_load_balancer_arns {
let mut array_1954 = object.key("GatewayLoadBalancerArns").start_array();
for item_1955 in var_1953 {
{
array_1954.value().string(item_1955.as_str());
}
}
array_1954.finish();
}
if let Some(var_1956) = &input.network_load_balancer_arns {
let mut array_1957 = object.key("NetworkLoadBalancerArns").start_array();
for item_1958 in var_1956 {
{
array_1957.value().string(item_1958.as_str());
}
}
array_1957.finish();
}
if let Some(var_1959) = &input.private_dns_name {
object.key("PrivateDnsName").string(var_1959.as_str());
}
if let Some(var_1960) = &input.service_id {
object.key("ServiceId").string(var_1960.as_str());
}
if let Some(var_1961) = &input.service_name {
object.key("ServiceName").string(var_1961.as_str());
}
if let Some(var_1962) = &input.service_state {
object.key("ServiceState").string(var_1962.as_str());
}
if let Some(var_1963) = &input.service_type {
let mut array_1964 = object.key("ServiceType").start_array();
for item_1965 in var_1963 {
{
#[allow(unused_mut)]
let mut object_1966 = array_1964.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_vpc_endpoint_service_service_type_details(&mut object_1966, item_1965)?;
object_1966.finish();
}
}
array_1964.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_xray_encryption_config_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsXrayEncryptionConfigDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1967) = &input.key_id {
object.key("KeyId").string(var_1967.as_str());
}
if let Some(var_1968) = &input.status {
object.key("Status").string(var_1968.as_str());
}
if let Some(var_1969) = &input.r#type {
object.key("Type").string(var_1969.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_waf_rate_based_rule_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafRateBasedRuleDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1970) = &input.metric_name {
object.key("MetricName").string(var_1970.as_str());
}
if let Some(var_1971) = &input.name {
object.key("Name").string(var_1971.as_str());
}
if let Some(var_1972) = &input.rate_key {
object.key("RateKey").string(var_1972.as_str());
}
if input.rate_limit != 0 {
object.key("RateLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.rate_limit).into()),
);
}
if let Some(var_1973) = &input.rule_id {
object.key("RuleId").string(var_1973.as_str());
}
if let Some(var_1974) = &input.match_predicates {
let mut array_1975 = object.key("MatchPredicates").start_array();
for item_1976 in var_1974 {
{
#[allow(unused_mut)]
let mut object_1977 = array_1975.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_waf_rate_based_rule_match_predicate(&mut object_1977, item_1976)?;
object_1977.finish();
}
}
array_1975.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_waf_regional_rate_based_rule_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafRegionalRateBasedRuleDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1978) = &input.metric_name {
object.key("MetricName").string(var_1978.as_str());
}
if let Some(var_1979) = &input.name {
object.key("Name").string(var_1979.as_str());
}
if let Some(var_1980) = &input.rate_key {
object.key("RateKey").string(var_1980.as_str());
}
if input.rate_limit != 0 {
object.key("RateLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.rate_limit).into()),
);
}
if let Some(var_1981) = &input.rule_id {
object.key("RuleId").string(var_1981.as_str());
}
if let Some(var_1982) = &input.match_predicates {
let mut array_1983 = object.key("MatchPredicates").start_array();
for item_1984 in var_1982 {
{
#[allow(unused_mut)]
let mut object_1985 = array_1983.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_waf_regional_rate_based_rule_match_predicate(&mut object_1985, item_1984)?;
object_1985.finish();
}
}
array_1983.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecr_repository_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcrRepositoryDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1986) = &input.arn {
object.key("Arn").string(var_1986.as_str());
}
if let Some(var_1987) = &input.image_scanning_configuration {
#[allow(unused_mut)]
let mut object_1988 = object.key("ImageScanningConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecr_repository_image_scanning_configuration_details(&mut object_1988, var_1987)?;
object_1988.finish();
}
if let Some(var_1989) = &input.image_tag_mutability {
object.key("ImageTagMutability").string(var_1989.as_str());
}
if let Some(var_1990) = &input.lifecycle_policy {
#[allow(unused_mut)]
let mut object_1991 = object.key("LifecyclePolicy").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecr_repository_lifecycle_policy_details(&mut object_1991, var_1990)?;
object_1991.finish();
}
if let Some(var_1992) = &input.repository_name {
object.key("RepositoryName").string(var_1992.as_str());
}
if let Some(var_1993) = &input.repository_policy_text {
object.key("RepositoryPolicyText").string(var_1993.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_eks_cluster_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEksClusterDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1994) = &input.arn {
object.key("Arn").string(var_1994.as_str());
}
if let Some(var_1995) = &input.certificate_authority_data {
object
.key("CertificateAuthorityData")
.string(var_1995.as_str());
}
if let Some(var_1996) = &input.cluster_status {
object.key("ClusterStatus").string(var_1996.as_str());
}
if let Some(var_1997) = &input.endpoint {
object.key("Endpoint").string(var_1997.as_str());
}
if let Some(var_1998) = &input.name {
object.key("Name").string(var_1998.as_str());
}
if let Some(var_1999) = &input.resources_vpc_config {
#[allow(unused_mut)]
let mut object_2000 = object.key("ResourcesVpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_aws_eks_cluster_resources_vpc_config_details(&mut object_2000, var_1999)?;
object_2000.finish();
}
if let Some(var_2001) = &input.role_arn {
object.key("RoleArn").string(var_2001.as_str());
}
if let Some(var_2002) = &input.version {
object.key("Version").string(var_2002.as_str());
}
if let Some(var_2003) = &input.logging {
#[allow(unused_mut)]
let mut object_2004 = object.key("Logging").start_object();
crate::json_ser::serialize_structure_crate_model_aws_eks_cluster_logging_details(
&mut object_2004,
var_2003,
)?;
object_2004.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_network_firewall_firewall_policy_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsNetworkFirewallFirewallPolicyDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2005) = &input.firewall_policy {
#[allow(unused_mut)]
let mut object_2006 = object.key("FirewallPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_firewall_policy_details(
&mut object_2006,
var_2005,
)?;
object_2006.finish();
}
if let Some(var_2007) = &input.firewall_policy_arn {
object.key("FirewallPolicyArn").string(var_2007.as_str());
}
if let Some(var_2008) = &input.firewall_policy_id {
object.key("FirewallPolicyId").string(var_2008.as_str());
}
if let Some(var_2009) = &input.firewall_policy_name {
object.key("FirewallPolicyName").string(var_2009.as_str());
}
if let Some(var_2010) = &input.description {
object.key("Description").string(var_2010.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_network_firewall_firewall_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsNetworkFirewallFirewallDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.delete_protection {
object
.key("DeleteProtection")
.boolean(input.delete_protection);
}
if let Some(var_2011) = &input.description {
object.key("Description").string(var_2011.as_str());
}
if let Some(var_2012) = &input.firewall_arn {
object.key("FirewallArn").string(var_2012.as_str());
}
if let Some(var_2013) = &input.firewall_id {
object.key("FirewallId").string(var_2013.as_str());
}
if let Some(var_2014) = &input.firewall_name {
object.key("FirewallName").string(var_2014.as_str());
}
if let Some(var_2015) = &input.firewall_policy_arn {
object.key("FirewallPolicyArn").string(var_2015.as_str());
}
if input.firewall_policy_change_protection {
object
.key("FirewallPolicyChangeProtection")
.boolean(input.firewall_policy_change_protection);
}
if input.subnet_change_protection {
object
.key("SubnetChangeProtection")
.boolean(input.subnet_change_protection);
}
if let Some(var_2016) = &input.subnet_mappings {
let mut array_2017 = object.key("SubnetMappings").start_array();
for item_2018 in var_2016 {
{
#[allow(unused_mut)]
let mut object_2019 = array_2017.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_network_firewall_firewall_subnet_mappings_details(&mut object_2019, item_2018)?;
object_2019.finish();
}
}
array_2017.finish();
}
if let Some(var_2020) = &input.vpc_id {
object.key("VpcId").string(var_2020.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_network_firewall_rule_group_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsNetworkFirewallRuleGroupDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.capacity != 0 {
object.key("Capacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.capacity).into()),
);
}
if let Some(var_2021) = &input.description {
object.key("Description").string(var_2021.as_str());
}
if let Some(var_2022) = &input.rule_group {
#[allow(unused_mut)]
let mut object_2023 = object.key("RuleGroup").start_object();
crate::json_ser::serialize_structure_crate_model_rule_group_details(
&mut object_2023,
var_2022,
)?;
object_2023.finish();
}
if let Some(var_2024) = &input.rule_group_arn {
object.key("RuleGroupArn").string(var_2024.as_str());
}
if let Some(var_2025) = &input.rule_group_id {
object.key("RuleGroupId").string(var_2025.as_str());
}
if let Some(var_2026) = &input.rule_group_name {
object.key("RuleGroupName").string(var_2026.as_str());
}
if let Some(var_2027) = &input.r#type {
object.key("Type").string(var_2027.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_rds_db_security_group_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRdsDbSecurityGroupDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2028) = &input.db_security_group_arn {
object.key("DbSecurityGroupArn").string(var_2028.as_str());
}
if let Some(var_2029) = &input.db_security_group_description {
object
.key("DbSecurityGroupDescription")
.string(var_2029.as_str());
}
if let Some(var_2030) = &input.db_security_group_name {
object.key("DbSecurityGroupName").string(var_2030.as_str());
}
if let Some(var_2031) = &input.ec2_security_groups {
let mut array_2032 = object.key("Ec2SecurityGroups").start_array();
for item_2033 in var_2031 {
{
#[allow(unused_mut)]
let mut object_2034 = array_2032.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_security_group_ec2_security_group(&mut object_2034, item_2033)?;
object_2034.finish();
}
}
array_2032.finish();
}
if let Some(var_2035) = &input.ip_ranges {
let mut array_2036 = object.key("IpRanges").start_array();
for item_2037 in var_2035 {
{
#[allow(unused_mut)]
let mut object_2038 = array_2036.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_security_group_ip_range(&mut object_2038, item_2037)?;
object_2038.finish();
}
}
array_2036.finish();
}
if let Some(var_2039) = &input.owner_id {
object.key("OwnerId").string(var_2039.as_str());
}
if let Some(var_2040) = &input.vpc_id {
object.key("VpcId").string(var_2040.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_kinesis_stream_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsKinesisStreamDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2041) = &input.name {
object.key("Name").string(var_2041.as_str());
}
if let Some(var_2042) = &input.arn {
object.key("Arn").string(var_2042.as_str());
}
if let Some(var_2043) = &input.stream_encryption {
#[allow(unused_mut)]
let mut object_2044 = object.key("StreamEncryption").start_object();
crate::json_ser::serialize_structure_crate_model_aws_kinesis_stream_stream_encryption_details(&mut object_2044, var_2043)?;
object_2044.finish();
}
if input.shard_count != 0 {
object.key("ShardCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.shard_count).into()),
);
}
if input.retention_period_hours != 0 {
object.key("RetentionPeriodHours").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.retention_period_hours).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_transit_gateway_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2TransitGatewayDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2045) = &input.id {
object.key("Id").string(var_2045.as_str());
}
if let Some(var_2046) = &input.description {
object.key("Description").string(var_2046.as_str());
}
if let Some(var_2047) = &input.default_route_table_propagation {
object
.key("DefaultRouteTablePropagation")
.string(var_2047.as_str());
}
if let Some(var_2048) = &input.auto_accept_shared_attachments {
object
.key("AutoAcceptSharedAttachments")
.string(var_2048.as_str());
}
if let Some(var_2049) = &input.default_route_table_association {
object
.key("DefaultRouteTableAssociation")
.string(var_2049.as_str());
}
if let Some(var_2050) = &input.transit_gateway_cidr_blocks {
let mut array_2051 = object.key("TransitGatewayCidrBlocks").start_array();
for item_2052 in var_2050 {
{
array_2051.value().string(item_2052.as_str());
}
}
array_2051.finish();
}
if let Some(var_2053) = &input.association_default_route_table_id {
object
.key("AssociationDefaultRouteTableId")
.string(var_2053.as_str());
}
if let Some(var_2054) = &input.propagation_default_route_table_id {
object
.key("PropagationDefaultRouteTableId")
.string(var_2054.as_str());
}
if let Some(var_2055) = &input.vpn_ecmp_support {
object.key("VpnEcmpSupport").string(var_2055.as_str());
}
if let Some(var_2056) = &input.dns_support {
object.key("DnsSupport").string(var_2056.as_str());
}
if let Some(var_2057) = &input.multicast_support {
object.key("MulticastSupport").string(var_2057.as_str());
}
if input.amazon_side_asn != 0 {
object.key("AmazonSideAsn").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.amazon_side_asn).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_efs_access_point_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEfsAccessPointDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2058) = &input.access_point_id {
object.key("AccessPointId").string(var_2058.as_str());
}
if let Some(var_2059) = &input.arn {
object.key("Arn").string(var_2059.as_str());
}
if let Some(var_2060) = &input.client_token {
object.key("ClientToken").string(var_2060.as_str());
}
if let Some(var_2061) = &input.file_system_id {
object.key("FileSystemId").string(var_2061.as_str());
}
if let Some(var_2062) = &input.posix_user {
#[allow(unused_mut)]
let mut object_2063 = object.key("PosixUser").start_object();
crate::json_ser::serialize_structure_crate_model_aws_efs_access_point_posix_user_details(
&mut object_2063,
var_2062,
)?;
object_2063.finish();
}
if let Some(var_2064) = &input.root_directory {
#[allow(unused_mut)]
let mut object_2065 = object.key("RootDirectory").start_object();
crate::json_ser::serialize_structure_crate_model_aws_efs_access_point_root_directory_details(&mut object_2065, var_2064)?;
object_2065.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_cloud_formation_stack_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCloudFormationStackDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2066) = &input.capabilities {
let mut array_2067 = object.key("Capabilities").start_array();
for item_2068 in var_2066 {
{
array_2067.value().string(item_2068.as_str());
}
}
array_2067.finish();
}
if let Some(var_2069) = &input.creation_time {
object.key("CreationTime").string(var_2069.as_str());
}
if let Some(var_2070) = &input.description {
object.key("Description").string(var_2070.as_str());
}
if input.disable_rollback {
object
.key("DisableRollback")
.boolean(input.disable_rollback);
}
if let Some(var_2071) = &input.drift_information {
#[allow(unused_mut)]
let mut object_2072 = object.key("DriftInformation").start_object();
crate::json_ser::serialize_structure_crate_model_aws_cloud_formation_stack_drift_information_details(&mut object_2072, var_2071)?;
object_2072.finish();
}
if input.enable_termination_protection {
object
.key("EnableTerminationProtection")
.boolean(input.enable_termination_protection);
}
if let Some(var_2073) = &input.last_updated_time {
object.key("LastUpdatedTime").string(var_2073.as_str());
}
if let Some(var_2074) = &input.notification_arns {
let mut array_2075 = object.key("NotificationArns").start_array();
for item_2076 in var_2074 {
{
array_2075.value().string(item_2076.as_str());
}
}
array_2075.finish();
}
if let Some(var_2077) = &input.outputs {
let mut array_2078 = object.key("Outputs").start_array();
for item_2079 in var_2077 {
{
#[allow(unused_mut)]
let mut object_2080 = array_2078.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_cloud_formation_stack_outputs_details(&mut object_2080, item_2079)?;
object_2080.finish();
}
}
array_2078.finish();
}
if let Some(var_2081) = &input.role_arn {
object.key("RoleArn").string(var_2081.as_str());
}
if let Some(var_2082) = &input.stack_id {
object.key("StackId").string(var_2082.as_str());
}
if let Some(var_2083) = &input.stack_name {
object.key("StackName").string(var_2083.as_str());
}
if let Some(var_2084) = &input.stack_status {
object.key("StackStatus").string(var_2084.as_str());
}
if let Some(var_2085) = &input.stack_status_reason {
object.key("StackStatusReason").string(var_2085.as_str());
}
if input.timeout_in_minutes != 0 {
object.key("TimeoutInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.timeout_in_minutes).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_cloud_watch_alarm_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCloudWatchAlarmDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.actions_enabled {
object.key("ActionsEnabled").boolean(input.actions_enabled);
}
if let Some(var_2086) = &input.alarm_actions {
let mut array_2087 = object.key("AlarmActions").start_array();
for item_2088 in var_2086 {
{
array_2087.value().string(item_2088.as_str());
}
}
array_2087.finish();
}
if let Some(var_2089) = &input.alarm_arn {
object.key("AlarmArn").string(var_2089.as_str());
}
if let Some(var_2090) = &input.alarm_configuration_updated_timestamp {
object
.key("AlarmConfigurationUpdatedTimestamp")
.string(var_2090.as_str());
}
if let Some(var_2091) = &input.alarm_description {
object.key("AlarmDescription").string(var_2091.as_str());
}
if let Some(var_2092) = &input.alarm_name {
object.key("AlarmName").string(var_2092.as_str());
}
if let Some(var_2093) = &input.comparison_operator {
object.key("ComparisonOperator").string(var_2093.as_str());
}
if input.datapoints_to_alarm != 0 {
object.key("DatapointsToAlarm").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.datapoints_to_alarm).into()),
);
}
if let Some(var_2094) = &input.dimensions {
let mut array_2095 = object.key("Dimensions").start_array();
for item_2096 in var_2094 {
{
#[allow(unused_mut)]
let mut object_2097 = array_2095.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_cloud_watch_alarm_dimensions_details(&mut object_2097, item_2096)?;
object_2097.finish();
}
}
array_2095.finish();
}
if let Some(var_2098) = &input.evaluate_low_sample_count_percentile {
object
.key("EvaluateLowSampleCountPercentile")
.string(var_2098.as_str());
}
if input.evaluation_periods != 0 {
object.key("EvaluationPeriods").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.evaluation_periods).into()),
);
}
if let Some(var_2099) = &input.extended_statistic {
object.key("ExtendedStatistic").string(var_2099.as_str());
}
if let Some(var_2100) = &input.insufficient_data_actions {
let mut array_2101 = object.key("InsufficientDataActions").start_array();
for item_2102 in var_2100 {
{
array_2101.value().string(item_2102.as_str());
}
}
array_2101.finish();
}
if let Some(var_2103) = &input.metric_name {
object.key("MetricName").string(var_2103.as_str());
}
if let Some(var_2104) = &input.namespace {
object.key("Namespace").string(var_2104.as_str());
}
if let Some(var_2105) = &input.ok_actions {
let mut array_2106 = object.key("OkActions").start_array();
for item_2107 in var_2105 {
{
array_2106.value().string(item_2107.as_str());
}
}
array_2106.finish();
}
if input.period != 0 {
object.key("Period").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.period).into()),
);
}
if let Some(var_2108) = &input.statistic {
object.key("Statistic").string(var_2108.as_str());
}
if input.threshold != 0.0 {
object.key("Threshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.threshold).into()),
);
}
if let Some(var_2109) = &input.threshold_metric_id {
object.key("ThresholdMetricId").string(var_2109.as_str());
}
if let Some(var_2110) = &input.treat_missing_data {
object.key("TreatMissingData").string(var_2110.as_str());
}
if let Some(var_2111) = &input.unit {
object.key("Unit").string(var_2111.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_vpc_peering_connection_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2VpcPeeringConnectionDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2112) = &input.accepter_vpc_info {
#[allow(unused_mut)]
let mut object_2113 = object.key("AccepterVpcInfo").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_vpc_peering_connection_vpc_info_details(&mut object_2113, var_2112)?;
object_2113.finish();
}
if let Some(var_2114) = &input.expiration_time {
object.key("ExpirationTime").string(var_2114.as_str());
}
if let Some(var_2115) = &input.requester_vpc_info {
#[allow(unused_mut)]
let mut object_2116 = object.key("RequesterVpcInfo").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_vpc_peering_connection_vpc_info_details(&mut object_2116, var_2115)?;
object_2116.finish();
}
if let Some(var_2117) = &input.status {
#[allow(unused_mut)]
let mut object_2118 = object.key("Status").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_vpc_peering_connection_status_details(&mut object_2118, var_2117)?;
object_2118.finish();
}
if let Some(var_2119) = &input.vpc_peering_connection_id {
object
.key("VpcPeeringConnectionId")
.string(var_2119.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_waf_regional_rule_group_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafRegionalRuleGroupDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2120) = &input.metric_name {
object.key("MetricName").string(var_2120.as_str());
}
if let Some(var_2121) = &input.name {
object.key("Name").string(var_2121.as_str());
}
if let Some(var_2122) = &input.rule_group_id {
object.key("RuleGroupId").string(var_2122.as_str());
}
if let Some(var_2123) = &input.rules {
let mut array_2124 = object.key("Rules").start_array();
for item_2125 in var_2123 {
{
#[allow(unused_mut)]
let mut object_2126 = array_2124.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_waf_regional_rule_group_rules_details(&mut object_2126, item_2125)?;
object_2126.finish();
}
}
array_2124.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_waf_regional_rule_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafRegionalRuleDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2127) = &input.metric_name {
object.key("MetricName").string(var_2127.as_str());
}
if let Some(var_2128) = &input.name {
object.key("Name").string(var_2128.as_str());
}
if let Some(var_2129) = &input.predicate_list {
let mut array_2130 = object.key("PredicateList").start_array();
for item_2131 in var_2129 {
{
#[allow(unused_mut)]
let mut object_2132 = array_2130.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_waf_regional_rule_predicate_list_details(&mut object_2132, item_2131)?;
object_2132.finish();
}
}
array_2130.finish();
}
if let Some(var_2133) = &input.rule_id {
object.key("RuleId").string(var_2133.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_waf_regional_web_acl_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafRegionalWebAclDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2134) = &input.default_action {
object.key("DefaultAction").string(var_2134.as_str());
}
if let Some(var_2135) = &input.metric_name {
object.key("MetricName").string(var_2135.as_str());
}
if let Some(var_2136) = &input.name {
object.key("Name").string(var_2136.as_str());
}
if let Some(var_2137) = &input.rules_list {
let mut array_2138 = object.key("RulesList").start_array();
for item_2139 in var_2137 {
{
#[allow(unused_mut)]
let mut object_2140 = array_2138.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_waf_regional_web_acl_rules_list_details(&mut object_2140, item_2139)?;
object_2140.finish();
}
}
array_2138.finish();
}
if let Some(var_2141) = &input.web_acl_id {
object.key("WebAclId").string(var_2141.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_waf_rule_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafRuleDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2142) = &input.metric_name {
object.key("MetricName").string(var_2142.as_str());
}
if let Some(var_2143) = &input.name {
object.key("Name").string(var_2143.as_str());
}
if let Some(var_2144) = &input.predicate_list {
let mut array_2145 = object.key("PredicateList").start_array();
for item_2146 in var_2144 {
{
#[allow(unused_mut)]
let mut object_2147 = array_2145.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_waf_rule_predicate_list_details(&mut object_2147, item_2146)?;
object_2147.finish();
}
}
array_2145.finish();
}
if let Some(var_2148) = &input.rule_id {
object.key("RuleId").string(var_2148.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_waf_rule_group_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafRuleGroupDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2149) = &input.metric_name {
object.key("MetricName").string(var_2149.as_str());
}
if let Some(var_2150) = &input.name {
object.key("Name").string(var_2150.as_str());
}
if let Some(var_2151) = &input.rule_group_id {
object.key("RuleGroupId").string(var_2151.as_str());
}
if let Some(var_2152) = &input.rules {
let mut array_2153 = object.key("Rules").start_array();
for item_2154 in var_2152 {
{
#[allow(unused_mut)]
let mut object_2155 = array_2153.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_waf_rule_group_rules_details(
&mut object_2155,
item_2154,
)?;
object_2155.finish();
}
}
array_2153.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2156) = &input.cluster_arn {
object.key("ClusterArn").string(var_2156.as_str());
}
if let Some(var_2157) = &input.task_definition_arn {
object.key("TaskDefinitionArn").string(var_2157.as_str());
}
if let Some(var_2158) = &input.version {
object.key("Version").string(var_2158.as_str());
}
if let Some(var_2159) = &input.created_at {
object.key("CreatedAt").string(var_2159.as_str());
}
if let Some(var_2160) = &input.started_at {
object.key("StartedAt").string(var_2160.as_str());
}
if let Some(var_2161) = &input.started_by {
object.key("StartedBy").string(var_2161.as_str());
}
if let Some(var_2162) = &input.group {
object.key("Group").string(var_2162.as_str());
}
if let Some(var_2163) = &input.volumes {
let mut array_2164 = object.key("Volumes").start_array();
for item_2165 in var_2163 {
{
#[allow(unused_mut)]
let mut object_2166 = array_2164.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_volume_details(
&mut object_2166,
item_2165,
)?;
object_2166.finish();
}
}
array_2164.finish();
}
if let Some(var_2167) = &input.containers {
let mut array_2168 = object.key("Containers").start_array();
for item_2169 in var_2167 {
{
#[allow(unused_mut)]
let mut object_2170 = array_2168.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_container_details(
&mut object_2170,
item_2169,
)?;
object_2170.finish();
}
}
array_2168.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_backup_backup_vault_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsBackupBackupVaultDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2171) = &input.backup_vault_arn {
object.key("BackupVaultArn").string(var_2171.as_str());
}
if let Some(var_2172) = &input.backup_vault_name {
object.key("BackupVaultName").string(var_2172.as_str());
}
if let Some(var_2173) = &input.encryption_key_arn {
object.key("EncryptionKeyArn").string(var_2173.as_str());
}
if let Some(var_2174) = &input.notifications {
#[allow(unused_mut)]
let mut object_2175 = object.key("Notifications").start_object();
crate::json_ser::serialize_structure_crate_model_aws_backup_backup_vault_notifications_details(&mut object_2175, var_2174)?;
object_2175.finish();
}
if let Some(var_2176) = &input.access_policy {
object.key("AccessPolicy").string(var_2176.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_backup_backup_plan_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsBackupBackupPlanDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2177) = &input.backup_plan {
#[allow(unused_mut)]
let mut object_2178 = object.key("BackupPlan").start_object();
crate::json_ser::serialize_structure_crate_model_aws_backup_backup_plan_backup_plan_details(&mut object_2178, var_2177)?;
object_2178.finish();
}
if let Some(var_2179) = &input.backup_plan_arn {
object.key("BackupPlanArn").string(var_2179.as_str());
}
if let Some(var_2180) = &input.backup_plan_id {
object.key("BackupPlanId").string(var_2180.as_str());
}
if let Some(var_2181) = &input.version_id {
object.key("VersionId").string(var_2181.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_backup_recovery_point_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsBackupRecoveryPointDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.backup_size_in_bytes != 0 {
object.key("BackupSizeInBytes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.backup_size_in_bytes).into()),
);
}
if let Some(var_2182) = &input.backup_vault_arn {
object.key("BackupVaultArn").string(var_2182.as_str());
}
if let Some(var_2183) = &input.backup_vault_name {
object.key("BackupVaultName").string(var_2183.as_str());
}
if let Some(var_2184) = &input.calculated_lifecycle {
#[allow(unused_mut)]
let mut object_2185 = object.key("CalculatedLifecycle").start_object();
crate::json_ser::serialize_structure_crate_model_aws_backup_recovery_point_calculated_lifecycle_details(&mut object_2185, var_2184)?;
object_2185.finish();
}
if let Some(var_2186) = &input.completion_date {
object.key("CompletionDate").string(var_2186.as_str());
}
if let Some(var_2187) = &input.created_by {
#[allow(unused_mut)]
let mut object_2188 = object.key("CreatedBy").start_object();
crate::json_ser::serialize_structure_crate_model_aws_backup_recovery_point_created_by_details(&mut object_2188, var_2187)?;
object_2188.finish();
}
if let Some(var_2189) = &input.creation_date {
object.key("CreationDate").string(var_2189.as_str());
}
if let Some(var_2190) = &input.encryption_key_arn {
object.key("EncryptionKeyArn").string(var_2190.as_str());
}
if let Some(var_2191) = &input.iam_role_arn {
object.key("IamRoleArn").string(var_2191.as_str());
}
if input.is_encrypted {
object.key("IsEncrypted").boolean(input.is_encrypted);
}
if let Some(var_2192) = &input.last_restore_time {
object.key("LastRestoreTime").string(var_2192.as_str());
}
if let Some(var_2193) = &input.lifecycle {
#[allow(unused_mut)]
let mut object_2194 = object.key("Lifecycle").start_object();
crate::json_ser::serialize_structure_crate_model_aws_backup_recovery_point_lifecycle_details(&mut object_2194, var_2193)?;
object_2194.finish();
}
if let Some(var_2195) = &input.recovery_point_arn {
object.key("RecoveryPointArn").string(var_2195.as_str());
}
if let Some(var_2196) = &input.resource_arn {
object.key("ResourceArn").string(var_2196.as_str());
}
if let Some(var_2197) = &input.resource_type {
object.key("ResourceType").string(var_2197.as_str());
}
if let Some(var_2198) = &input.source_backup_vault_arn {
object.key("SourceBackupVaultArn").string(var_2198.as_str());
}
if let Some(var_2199) = &input.status {
object.key("Status").string(var_2199.as_str());
}
if let Some(var_2200) = &input.status_message {
object.key("StatusMessage").string(var_2200.as_str());
}
if let Some(var_2201) = &input.storage_class {
object.key("StorageClass").string(var_2201.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2202) = &input.launch_template_name {
object.key("LaunchTemplateName").string(var_2202.as_str());
}
if let Some(var_2203) = &input.id {
object.key("Id").string(var_2203.as_str());
}
if let Some(var_2204) = &input.launch_template_data {
#[allow(unused_mut)]
let mut object_2205 = object.key("LaunchTemplateData").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_details(
&mut object_2205,
var_2204,
)?;
object_2205.finish();
}
if input.default_version_number != 0 {
object.key("DefaultVersionNumber").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.default_version_number).into()),
);
}
if input.latest_version_number != 0 {
object.key("LatestVersionNumber").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.latest_version_number).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_sage_maker_notebook_instance_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsSageMakerNotebookInstanceDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2206) = &input.accelerator_types {
let mut array_2207 = object.key("AcceleratorTypes").start_array();
for item_2208 in var_2206 {
{
array_2207.value().string(item_2208.as_str());
}
}
array_2207.finish();
}
if let Some(var_2209) = &input.additional_code_repositories {
let mut array_2210 = object.key("AdditionalCodeRepositories").start_array();
for item_2211 in var_2209 {
{
array_2210.value().string(item_2211.as_str());
}
}
array_2210.finish();
}
if let Some(var_2212) = &input.default_code_repository {
object
.key("DefaultCodeRepository")
.string(var_2212.as_str());
}
if let Some(var_2213) = &input.direct_internet_access {
object.key("DirectInternetAccess").string(var_2213.as_str());
}
if let Some(var_2214) = &input.failure_reason {
object.key("FailureReason").string(var_2214.as_str());
}
if let Some(var_2215) = &input.instance_metadata_service_configuration {
#[allow(unused_mut)]
let mut object_2216 = object
.key("InstanceMetadataServiceConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_aws_sage_maker_notebook_instance_metadata_service_configuration_details(&mut object_2216, var_2215)?;
object_2216.finish();
}
if let Some(var_2217) = &input.instance_type {
object.key("InstanceType").string(var_2217.as_str());
}
if let Some(var_2218) = &input.kms_key_id {
object.key("KmsKeyId").string(var_2218.as_str());
}
if let Some(var_2219) = &input.network_interface_id {
object.key("NetworkInterfaceId").string(var_2219.as_str());
}
if let Some(var_2220) = &input.notebook_instance_arn {
object.key("NotebookInstanceArn").string(var_2220.as_str());
}
if let Some(var_2221) = &input.notebook_instance_lifecycle_config_name {
object
.key("NotebookInstanceLifecycleConfigName")
.string(var_2221.as_str());
}
if let Some(var_2222) = &input.notebook_instance_name {
object.key("NotebookInstanceName").string(var_2222.as_str());
}
if let Some(var_2223) = &input.notebook_instance_status {
object
.key("NotebookInstanceStatus")
.string(var_2223.as_str());
}
if let Some(var_2224) = &input.platform_identifier {
object.key("PlatformIdentifier").string(var_2224.as_str());
}
if let Some(var_2225) = &input.role_arn {
object.key("RoleArn").string(var_2225.as_str());
}
if let Some(var_2226) = &input.root_access {
object.key("RootAccess").string(var_2226.as_str());
}
if let Some(var_2227) = &input.security_groups {
let mut array_2228 = object.key("SecurityGroups").start_array();
for item_2229 in var_2227 {
{
array_2228.value().string(item_2229.as_str());
}
}
array_2228.finish();
}
if let Some(var_2230) = &input.subnet_id {
object.key("SubnetId").string(var_2230.as_str());
}
if let Some(var_2231) = &input.url {
object.key("Url").string(var_2231.as_str());
}
if input.volume_size_in_gb != 0 {
object.key("VolumeSizeInGB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.volume_size_in_gb).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_wafv2_web_acl_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafv2WebAclDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2232) = &input.name {
object.key("Name").string(var_2232.as_str());
}
if let Some(var_2233) = &input.arn {
object.key("Arn").string(var_2233.as_str());
}
if input.managedby_firewall_manager {
object
.key("ManagedbyFirewallManager")
.boolean(input.managedby_firewall_manager);
}
if let Some(var_2234) = &input.id {
object.key("Id").string(var_2234.as_str());
}
if input.capacity != 0 {
object.key("Capacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.capacity).into()),
);
}
if let Some(var_2235) = &input.captcha_config {
#[allow(unused_mut)]
let mut object_2236 = object.key("CaptchaConfig").start_object();
crate::json_ser::serialize_structure_crate_model_aws_wafv2_web_acl_captcha_config_details(
&mut object_2236,
var_2235,
)?;
object_2236.finish();
}
if let Some(var_2237) = &input.default_action {
#[allow(unused_mut)]
let mut object_2238 = object.key("DefaultAction").start_object();
crate::json_ser::serialize_structure_crate_model_aws_wafv2_web_acl_action_details(
&mut object_2238,
var_2237,
)?;
object_2238.finish();
}
if let Some(var_2239) = &input.description {
object.key("Description").string(var_2239.as_str());
}
if let Some(var_2240) = &input.rules {
let mut array_2241 = object.key("Rules").start_array();
for item_2242 in var_2240 {
{
#[allow(unused_mut)]
let mut object_2243 = array_2241.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_wafv2_rules_details(
&mut object_2243,
item_2242,
)?;
object_2243.finish();
}
}
array_2241.finish();
}
if let Some(var_2244) = &input.visibility_config {
#[allow(unused_mut)]
let mut object_2245 = object.key("VisibilityConfig").start_object();
crate::json_ser::serialize_structure_crate_model_aws_wafv2_visibility_config_details(
&mut object_2245,
var_2244,
)?;
object_2245.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_wafv2_rule_group_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafv2RuleGroupDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.capacity != 0 {
object.key("Capacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.capacity).into()),
);
}
if let Some(var_2246) = &input.description {
object.key("Description").string(var_2246.as_str());
}
if let Some(var_2247) = &input.id {
object.key("Id").string(var_2247.as_str());
}
if let Some(var_2248) = &input.name {
object.key("Name").string(var_2248.as_str());
}
if let Some(var_2249) = &input.arn {
object.key("Arn").string(var_2249.as_str());
}
if let Some(var_2250) = &input.rules {
let mut array_2251 = object.key("Rules").start_array();
for item_2252 in var_2250 {
{
#[allow(unused_mut)]
let mut object_2253 = array_2251.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_wafv2_rules_details(
&mut object_2253,
item_2252,
)?;
object_2253.finish();
}
}
array_2251.finish();
}
if let Some(var_2254) = &input.scope {
object.key("Scope").string(var_2254.as_str());
}
if let Some(var_2255) = &input.visibility_config {
#[allow(unused_mut)]
let mut object_2256 = object.key("VisibilityConfig").start_object();
crate::json_ser::serialize_structure_crate_model_aws_wafv2_visibility_config_details(
&mut object_2256,
var_2255,
)?;
object_2256.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_adjustment(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Adjustment,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2257) = &input.metric {
object.key("Metric").string(var_2257.as_str());
}
if let Some(var_2258) = &input.reason {
object.key("Reason").string(var_2258.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_action_remote_ip_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ActionRemoteIpDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2259) = &input.ip_address_v4 {
object.key("IpAddressV4").string(var_2259.as_str());
}
if let Some(var_2260) = &input.organization {
#[allow(unused_mut)]
let mut object_2261 = object.key("Organization").start_object();
crate::json_ser::serialize_structure_crate_model_ip_organization_details(
&mut object_2261,
var_2260,
)?;
object_2261.finish();
}
if let Some(var_2262) = &input.country {
#[allow(unused_mut)]
let mut object_2263 = object.key("Country").start_object();
crate::json_ser::serialize_structure_crate_model_country(&mut object_2263, var_2262)?;
object_2263.finish();
}
if let Some(var_2264) = &input.city {
#[allow(unused_mut)]
let mut object_2265 = object.key("City").start_object();
crate::json_ser::serialize_structure_crate_model_city(&mut object_2265, var_2264)?;
object_2265.finish();
}
if let Some(var_2266) = &input.geo_location {
#[allow(unused_mut)]
let mut object_2267 = object.key("GeoLocation").start_object();
crate::json_ser::serialize_structure_crate_model_geo_location(&mut object_2267, var_2266)?;
object_2267.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_action_remote_port_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ActionRemotePortDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.port != 0 {
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port).into()),
);
}
if let Some(var_2268) = &input.port_name {
object.key("PortName").string(var_2268.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_action_local_port_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ActionLocalPortDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.port != 0 {
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port).into()),
);
}
if let Some(var_2269) = &input.port_name {
object.key("PortName").string(var_2269.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_api_call_action_domain_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsApiCallActionDomainDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2270) = &input.domain {
object.key("Domain").string(var_2270.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_port_probe_detail(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PortProbeDetail,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2271) = &input.local_port_details {
#[allow(unused_mut)]
let mut object_2272 = object.key("LocalPortDetails").start_object();
crate::json_ser::serialize_structure_crate_model_action_local_port_details(
&mut object_2272,
var_2271,
)?;
object_2272.finish();
}
if let Some(var_2273) = &input.local_ip_details {
#[allow(unused_mut)]
let mut object_2274 = object.key("LocalIpDetails").start_object();
crate::json_ser::serialize_structure_crate_model_action_local_ip_details(
&mut object_2274,
var_2273,
)?;
object_2274.finish();
}
if let Some(var_2275) = &input.remote_ip_details {
#[allow(unused_mut)]
let mut object_2276 = object.key("RemoteIpDetails").start_object();
crate::json_ser::serialize_structure_crate_model_action_remote_ip_details(
&mut object_2276,
var_2275,
)?;
object_2276.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_classification_status(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ClassificationStatus,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2277) = &input.code {
object.key("Code").string(var_2277.as_str());
}
if let Some(var_2278) = &input.reason {
object.key("Reason").string(var_2278.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sensitive_data_result(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SensitiveDataResult,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2279) = &input.category {
object.key("Category").string(var_2279.as_str());
}
if let Some(var_2280) = &input.detections {
let mut array_2281 = object.key("Detections").start_array();
for item_2282 in var_2280 {
{
#[allow(unused_mut)]
let mut object_2283 = array_2281.value().start_object();
crate::json_ser::serialize_structure_crate_model_sensitive_data_detections(
&mut object_2283,
item_2282,
)?;
object_2283.finish();
}
}
array_2281.finish();
}
if input.total_count != 0 {
object.key("TotalCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.total_count).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_data_identifiers_result(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomDataIdentifiersResult,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2284) = &input.detections {
let mut array_2285 = object.key("Detections").start_array();
for item_2286 in var_2284 {
{
#[allow(unused_mut)]
let mut object_2287 = array_2285.value().start_object();
crate::json_ser::serialize_structure_crate_model_custom_data_identifiers_detections(&mut object_2287, item_2286)?;
object_2287.finish();
}
}
array_2285.finish();
}
if input.total_count != 0 {
object.key("TotalCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.total_count).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_auto_scaling_auto_scaling_group_mixed_instances_policy_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsAutoScalingAutoScalingGroupMixedInstancesPolicyDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2288) = &input.instances_distribution {
#[allow(unused_mut)]
let mut object_2289 = object.key("InstancesDistribution").start_object();
crate::json_ser::serialize_structure_crate_model_aws_auto_scaling_auto_scaling_group_mixed_instances_policy_instances_distribution_details(&mut object_2289, var_2288)?;
object_2289.finish();
}
if let Some(var_2290) = &input.launch_template {
#[allow(unused_mut)]
let mut object_2291 = object.key("LaunchTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_aws_auto_scaling_auto_scaling_group_mixed_instances_policy_launch_template_details(&mut object_2291, var_2290)?;
object_2291.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_auto_scaling_auto_scaling_group_availability_zones_list_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsAutoScalingAutoScalingGroupAvailabilityZonesListDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2292) = &input.value {
object.key("Value").string(var_2292.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_auto_scaling_auto_scaling_group_launch_template_launch_template_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsAutoScalingAutoScalingGroupLaunchTemplateLaunchTemplateSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2293) = &input.launch_template_id {
object.key("LaunchTemplateId").string(var_2293.as_str());
}
if let Some(var_2294) = &input.launch_template_name {
object.key("LaunchTemplateName").string(var_2294.as_str());
}
if let Some(var_2295) = &input.version {
object.key("Version").string(var_2295.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_code_build_project_artifacts_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCodeBuildProjectArtifactsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2296) = &input.artifact_identifier {
object.key("ArtifactIdentifier").string(var_2296.as_str());
}
if input.encryption_disabled {
object
.key("EncryptionDisabled")
.boolean(input.encryption_disabled);
}
if let Some(var_2297) = &input.location {
object.key("Location").string(var_2297.as_str());
}
if let Some(var_2298) = &input.name {
object.key("Name").string(var_2298.as_str());
}
if let Some(var_2299) = &input.namespace_type {
object.key("NamespaceType").string(var_2299.as_str());
}
if input.override_artifact_name {
object
.key("OverrideArtifactName")
.boolean(input.override_artifact_name);
}
if let Some(var_2300) = &input.packaging {
object.key("Packaging").string(var_2300.as_str());
}
if let Some(var_2301) = &input.path {
object.key("Path").string(var_2301.as_str());
}
if let Some(var_2302) = &input.r#type {
object.key("Type").string(var_2302.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_code_build_project_environment(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCodeBuildProjectEnvironment,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2303) = &input.certificate {
object.key("Certificate").string(var_2303.as_str());
}
if let Some(var_2304) = &input.environment_variables {
let mut array_2305 = object.key("EnvironmentVariables").start_array();
for item_2306 in var_2304 {
{
#[allow(unused_mut)]
let mut object_2307 = array_2305.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_code_build_project_environment_environment_variables_details(&mut object_2307, item_2306)?;
object_2307.finish();
}
}
array_2305.finish();
}
if input.privileged_mode {
object.key("PrivilegedMode").boolean(input.privileged_mode);
}
if let Some(var_2308) = &input.image_pull_credentials_type {
object
.key("ImagePullCredentialsType")
.string(var_2308.as_str());
}
if let Some(var_2309) = &input.registry_credential {
#[allow(unused_mut)]
let mut object_2310 = object.key("RegistryCredential").start_object();
crate::json_ser::serialize_structure_crate_model_aws_code_build_project_environment_registry_credential(&mut object_2310, var_2309)?;
object_2310.finish();
}
if let Some(var_2311) = &input.r#type {
object.key("Type").string(var_2311.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_code_build_project_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCodeBuildProjectSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2312) = &input.r#type {
object.key("Type").string(var_2312.as_str());
}
if let Some(var_2313) = &input.location {
object.key("Location").string(var_2313.as_str());
}
if input.git_clone_depth != 0 {
object.key("GitCloneDepth").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.git_clone_depth).into()),
);
}
if input.insecure_ssl {
object.key("InsecureSsl").boolean(input.insecure_ssl);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_code_build_project_logs_config_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCodeBuildProjectLogsConfigDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2314) = &input.cloud_watch_logs {
#[allow(unused_mut)]
let mut object_2315 = object.key("CloudWatchLogs").start_object();
crate::json_ser::serialize_structure_crate_model_aws_code_build_project_logs_config_cloud_watch_logs_details(&mut object_2315, var_2314)?;
object_2315.finish();
}
if let Some(var_2316) = &input.s3_logs {
#[allow(unused_mut)]
let mut object_2317 = object.key("S3Logs").start_object();
crate::json_ser::serialize_structure_crate_model_aws_code_build_project_logs_config_s3_logs_details(&mut object_2317, var_2316)?;
object_2317.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_code_build_project_vpc_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCodeBuildProjectVpcConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2318) = &input.vpc_id {
object.key("VpcId").string(var_2318.as_str());
}
if let Some(var_2319) = &input.subnets {
let mut array_2320 = object.key("Subnets").start_array();
for item_2321 in var_2319 {
{
array_2320.value().string(item_2321.as_str());
}
}
array_2320.finish();
}
if let Some(var_2322) = &input.security_group_ids {
let mut array_2323 = object.key("SecurityGroupIds").start_array();
for item_2324 in var_2322 {
{
array_2323.value().string(item_2324.as_str());
}
}
array_2323.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_cloud_front_distribution_cache_behaviors(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCloudFrontDistributionCacheBehaviors,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2325) = &input.items {
let mut array_2326 = object.key("Items").start_array();
for item_2327 in var_2325 {
{
#[allow(unused_mut)]
let mut object_2328 = array_2326.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_cache_behavior(&mut object_2328, item_2327)?;
object_2328.finish();
}
}
array_2326.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_cloud_front_distribution_default_cache_behavior(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCloudFrontDistributionDefaultCacheBehavior,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2329) = &input.viewer_protocol_policy {
object.key("ViewerProtocolPolicy").string(var_2329.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_cloud_front_distribution_logging(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCloudFrontDistributionLogging,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2330) = &input.bucket {
object.key("Bucket").string(var_2330.as_str());
}
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if input.include_cookies {
object.key("IncludeCookies").boolean(input.include_cookies);
}
if let Some(var_2331) = &input.prefix {
object.key("Prefix").string(var_2331.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_cloud_front_distribution_origins(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCloudFrontDistributionOrigins,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2332) = &input.items {
let mut array_2333 = object.key("Items").start_array();
for item_2334 in var_2332 {
{
#[allow(unused_mut)]
let mut object_2335 = array_2333.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_origin_item(&mut object_2335, item_2334)?;
object_2335.finish();
}
}
array_2333.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_cloud_front_distribution_origin_groups(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCloudFrontDistributionOriginGroups,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2336) = &input.items {
let mut array_2337 = object.key("Items").start_array();
for item_2338 in var_2336 {
{
#[allow(unused_mut)]
let mut object_2339 = array_2337.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_origin_group(&mut object_2339, item_2338)?;
object_2339.finish();
}
}
array_2337.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_cloud_front_distribution_viewer_certificate(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCloudFrontDistributionViewerCertificate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2340) = &input.acm_certificate_arn {
object.key("AcmCertificateArn").string(var_2340.as_str());
}
if let Some(var_2341) = &input.certificate {
object.key("Certificate").string(var_2341.as_str());
}
if let Some(var_2342) = &input.certificate_source {
object.key("CertificateSource").string(var_2342.as_str());
}
if input.cloud_front_default_certificate {
object
.key("CloudFrontDefaultCertificate")
.boolean(input.cloud_front_default_certificate);
}
if let Some(var_2343) = &input.iam_certificate_id {
object.key("IamCertificateId").string(var_2343.as_str());
}
if let Some(var_2344) = &input.minimum_protocol_version {
object
.key("MinimumProtocolVersion")
.string(var_2344.as_str());
}
if let Some(var_2345) = &input.ssl_support_method {
object.key("SslSupportMethod").string(var_2345.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_instance_network_interfaces_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2InstanceNetworkInterfacesDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2346) = &input.network_interface_id {
object.key("NetworkInterfaceId").string(var_2346.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_instance_metadata_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2InstanceMetadataOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2347) = &input.http_endpoint {
object.key("HttpEndpoint").string(var_2347.as_str());
}
if let Some(var_2348) = &input.http_protocol_ipv6 {
object.key("HttpProtocolIpv6").string(var_2348.as_str());
}
if input.http_put_response_hop_limit != 0 {
object.key("HttpPutResponseHopLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.http_put_response_hop_limit).into()),
);
}
if let Some(var_2349) = &input.http_tokens {
object.key("HttpTokens").string(var_2349.as_str());
}
if let Some(var_2350) = &input.instance_metadata_tags {
object.key("InstanceMetadataTags").string(var_2350.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_network_interface_attachment(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2NetworkInterfaceAttachment,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2351) = &input.attach_time {
object.key("AttachTime").string(var_2351.as_str());
}
if let Some(var_2352) = &input.attachment_id {
object.key("AttachmentId").string(var_2352.as_str());
}
if input.delete_on_termination {
object
.key("DeleteOnTermination")
.boolean(input.delete_on_termination);
}
if input.device_index != 0 {
object.key("DeviceIndex").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.device_index).into()),
);
}
if let Some(var_2353) = &input.instance_id {
object.key("InstanceId").string(var_2353.as_str());
}
if let Some(var_2354) = &input.instance_owner_id {
object.key("InstanceOwnerId").string(var_2354.as_str());
}
if let Some(var_2355) = &input.status {
object.key("Status").string(var_2355.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_network_interface_security_group(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2NetworkInterfaceSecurityGroup,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2356) = &input.group_name {
object.key("GroupName").string(var_2356.as_str());
}
if let Some(var_2357) = &input.group_id {
object.key("GroupId").string(var_2357.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_network_interface_ip_v6_address_detail(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2NetworkInterfaceIpV6AddressDetail,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2358) = &input.ip_v6_address {
object.key("IpV6Address").string(var_2358.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_network_interface_private_ip_address_detail(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2NetworkInterfacePrivateIpAddressDetail,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2359) = &input.private_ip_address {
object.key("PrivateIpAddress").string(var_2359.as_str());
}
if let Some(var_2360) = &input.private_dns_name {
object.key("PrivateDnsName").string(var_2360.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_security_group_ip_permission(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2SecurityGroupIpPermission,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2361) = &input.ip_protocol {
object.key("IpProtocol").string(var_2361.as_str());
}
if input.from_port != 0 {
object.key("FromPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.from_port).into()),
);
}
if input.to_port != 0 {
object.key("ToPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.to_port).into()),
);
}
if let Some(var_2362) = &input.user_id_group_pairs {
let mut array_2363 = object.key("UserIdGroupPairs").start_array();
for item_2364 in var_2362 {
{
#[allow(unused_mut)]
let mut object_2365 = array_2363.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_security_group_user_id_group_pair(&mut object_2365, item_2364)?;
object_2365.finish();
}
}
array_2363.finish();
}
if let Some(var_2366) = &input.ip_ranges {
let mut array_2367 = object.key("IpRanges").start_array();
for item_2368 in var_2366 {
{
#[allow(unused_mut)]
let mut object_2369 = array_2367.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_security_group_ip_range(
&mut object_2369,
item_2368,
)?;
object_2369.finish();
}
}
array_2367.finish();
}
if let Some(var_2370) = &input.ipv6_ranges {
let mut array_2371 = object.key("Ipv6Ranges").start_array();
for item_2372 in var_2370 {
{
#[allow(unused_mut)]
let mut object_2373 = array_2371.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_security_group_ipv6_range(
&mut object_2373,
item_2372,
)?;
object_2373.finish();
}
}
array_2371.finish();
}
if let Some(var_2374) = &input.prefix_list_ids {
let mut array_2375 = object.key("PrefixListIds").start_array();
for item_2376 in var_2374 {
{
#[allow(unused_mut)]
let mut object_2377 = array_2375.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_security_group_prefix_list_id(&mut object_2377, item_2376)?;
object_2377.finish();
}
}
array_2375.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_volume_attachment(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2VolumeAttachment,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2378) = &input.attach_time {
object.key("AttachTime").string(var_2378.as_str());
}
if input.delete_on_termination {
object
.key("DeleteOnTermination")
.boolean(input.delete_on_termination);
}
if let Some(var_2379) = &input.instance_id {
object.key("InstanceId").string(var_2379.as_str());
}
if let Some(var_2380) = &input.status {
object.key("Status").string(var_2380.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_cidr_block_association(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CidrBlockAssociation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2381) = &input.association_id {
object.key("AssociationId").string(var_2381.as_str());
}
if let Some(var_2382) = &input.cidr_block {
object.key("CidrBlock").string(var_2382.as_str());
}
if let Some(var_2383) = &input.cidr_block_state {
object.key("CidrBlockState").string(var_2383.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ipv6_cidr_block_association(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Ipv6CidrBlockAssociation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2384) = &input.association_id {
object.key("AssociationId").string(var_2384.as_str());
}
if let Some(var_2385) = &input.ipv6_cidr_block {
object.key("Ipv6CidrBlock").string(var_2385.as_str());
}
if let Some(var_2386) = &input.cidr_block_state {
object.key("CidrBlockState").string(var_2386.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_network_acl_association(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2NetworkAclAssociation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2387) = &input.network_acl_association_id {
object
.key("NetworkAclAssociationId")
.string(var_2387.as_str());
}
if let Some(var_2388) = &input.network_acl_id {
object.key("NetworkAclId").string(var_2388.as_str());
}
if let Some(var_2389) = &input.subnet_id {
object.key("SubnetId").string(var_2389.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_network_acl_entry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2NetworkAclEntry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2390) = &input.cidr_block {
object.key("CidrBlock").string(var_2390.as_str());
}
if input.egress {
object.key("Egress").boolean(input.egress);
}
if let Some(var_2391) = &input.icmp_type_code {
#[allow(unused_mut)]
let mut object_2392 = object.key("IcmpTypeCode").start_object();
crate::json_ser::serialize_structure_crate_model_icmp_type_code(
&mut object_2392,
var_2391,
)?;
object_2392.finish();
}
if let Some(var_2393) = &input.ipv6_cidr_block {
object.key("Ipv6CidrBlock").string(var_2393.as_str());
}
if let Some(var_2394) = &input.port_range {
#[allow(unused_mut)]
let mut object_2395 = object.key("PortRange").start_object();
crate::json_ser::serialize_structure_crate_model_port_range_from_to(
&mut object_2395,
var_2394,
)?;
object_2395.finish();
}
if let Some(var_2396) = &input.protocol {
object.key("Protocol").string(var_2396.as_str());
}
if let Some(var_2397) = &input.rule_action {
object.key("RuleAction").string(var_2397.as_str());
}
if input.rule_number != 0 {
object.key("RuleNumber").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.rule_number).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_availability_zone(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AvailabilityZone,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2398) = &input.zone_name {
object.key("ZoneName").string(var_2398.as_str());
}
if let Some(var_2399) = &input.subnet_id {
object.key("SubnetId").string(var_2399.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_load_balancer_state(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoadBalancerState,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2400) = &input.code {
object.key("Code").string(var_2400.as_str());
}
if let Some(var_2401) = &input.reason {
object.key("Reason").string(var_2401.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elbv2_load_balancer_attribute(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElbv2LoadBalancerAttribute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2402) = &input.key {
object.key("Key").string(var_2402.as_str());
}
if let Some(var_2403) = &input.value {
object.key("Value").string(var_2403.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elastic_beanstalk_environment_environment_link(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElasticBeanstalkEnvironmentEnvironmentLink,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2404) = &input.environment_name {
object.key("EnvironmentName").string(var_2404.as_str());
}
if let Some(var_2405) = &input.link_name {
object.key("LinkName").string(var_2405.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elastic_beanstalk_environment_option_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElasticBeanstalkEnvironmentOptionSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2406) = &input.namespace {
object.key("Namespace").string(var_2406.as_str());
}
if let Some(var_2407) = &input.option_name {
object.key("OptionName").string(var_2407.as_str());
}
if let Some(var_2408) = &input.resource_name {
object.key("ResourceName").string(var_2408.as_str());
}
if let Some(var_2409) = &input.value {
object.key("Value").string(var_2409.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elastic_beanstalk_environment_tier(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElasticBeanstalkEnvironmentTier,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2410) = &input.name {
object.key("Name").string(var_2410.as_str());
}
if let Some(var_2411) = &input.r#type {
object.key("Type").string(var_2411.as_str());
}
if let Some(var_2412) = &input.version {
object.key("Version").string(var_2412.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elasticsearch_domain_domain_endpoint_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElasticsearchDomainDomainEndpointOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enforce_https {
object.key("EnforceHTTPS").boolean(input.enforce_https);
}
if let Some(var_2413) = &input.tls_security_policy {
object.key("TLSSecurityPolicy").string(var_2413.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elasticsearch_domain_elasticsearch_cluster_config_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElasticsearchDomainElasticsearchClusterConfigDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.dedicated_master_count != 0 {
object.key("DedicatedMasterCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.dedicated_master_count).into()),
);
}
if input.dedicated_master_enabled {
object
.key("DedicatedMasterEnabled")
.boolean(input.dedicated_master_enabled);
}
if let Some(var_2414) = &input.dedicated_master_type {
object.key("DedicatedMasterType").string(var_2414.as_str());
}
if input.instance_count != 0 {
object.key("InstanceCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.instance_count).into()),
);
}
if let Some(var_2415) = &input.instance_type {
object.key("InstanceType").string(var_2415.as_str());
}
if let Some(var_2416) = &input.zone_awareness_config {
#[allow(unused_mut)]
let mut object_2417 = object.key("ZoneAwarenessConfig").start_object();
crate::json_ser::serialize_structure_crate_model_aws_elasticsearch_domain_elasticsearch_cluster_config_zone_awareness_config_details(&mut object_2417, var_2416)?;
object_2417.finish();
}
if input.zone_awareness_enabled {
object
.key("ZoneAwarenessEnabled")
.boolean(input.zone_awareness_enabled);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elasticsearch_domain_encryption_at_rest_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElasticsearchDomainEncryptionAtRestOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_2418) = &input.kms_key_id {
object.key("KmsKeyId").string(var_2418.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elasticsearch_domain_log_publishing_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElasticsearchDomainLogPublishingOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2419) = &input.index_slow_logs {
#[allow(unused_mut)]
let mut object_2420 = object.key("IndexSlowLogs").start_object();
crate::json_ser::serialize_structure_crate_model_aws_elasticsearch_domain_log_publishing_options_log_config(&mut object_2420, var_2419)?;
object_2420.finish();
}
if let Some(var_2421) = &input.search_slow_logs {
#[allow(unused_mut)]
let mut object_2422 = object.key("SearchSlowLogs").start_object();
crate::json_ser::serialize_structure_crate_model_aws_elasticsearch_domain_log_publishing_options_log_config(&mut object_2422, var_2421)?;
object_2422.finish();
}
if let Some(var_2423) = &input.audit_logs {
#[allow(unused_mut)]
let mut object_2424 = object.key("AuditLogs").start_object();
crate::json_ser::serialize_structure_crate_model_aws_elasticsearch_domain_log_publishing_options_log_config(&mut object_2424, var_2423)?;
object_2424.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elasticsearch_domain_node_to_node_encryption_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElasticsearchDomainNodeToNodeEncryptionOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elasticsearch_domain_service_software_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElasticsearchDomainServiceSoftwareOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2425) = &input.automated_update_date {
object.key("AutomatedUpdateDate").string(var_2425.as_str());
}
if input.cancellable {
object.key("Cancellable").boolean(input.cancellable);
}
if let Some(var_2426) = &input.current_version {
object.key("CurrentVersion").string(var_2426.as_str());
}
if let Some(var_2427) = &input.description {
object.key("Description").string(var_2427.as_str());
}
if let Some(var_2428) = &input.new_version {
object.key("NewVersion").string(var_2428.as_str());
}
if input.update_available {
object
.key("UpdateAvailable")
.boolean(input.update_available);
}
if let Some(var_2429) = &input.update_status {
object.key("UpdateStatus").string(var_2429.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elasticsearch_domain_vpc_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElasticsearchDomainVpcOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2430) = &input.availability_zones {
let mut array_2431 = object.key("AvailabilityZones").start_array();
for item_2432 in var_2430 {
{
array_2431.value().string(item_2432.as_str());
}
}
array_2431.finish();
}
if let Some(var_2433) = &input.security_group_ids {
let mut array_2434 = object.key("SecurityGroupIds").start_array();
for item_2435 in var_2433 {
{
array_2434.value().string(item_2435.as_str());
}
}
array_2434.finish();
}
if let Some(var_2436) = &input.subnet_ids {
let mut array_2437 = object.key("SubnetIds").start_array();
for item_2438 in var_2436 {
{
array_2437.value().string(item_2438.as_str());
}
}
array_2437.finish();
}
if let Some(var_2439) = &input.vpc_id {
object.key("VPCId").string(var_2439.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_server_side_encryption_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketServerSideEncryptionConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2440) = &input.rules {
let mut array_2441 = object.key("Rules").start_array();
for item_2442 in var_2440 {
{
#[allow(unused_mut)]
let mut object_2443 = array_2441.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_server_side_encryption_rule(&mut object_2443, item_2442)?;
object_2443.finish();
}
}
array_2441.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketBucketLifecycleConfigurationDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2444) = &input.rules {
let mut array_2445 = object.key("Rules").start_array();
for item_2446 in var_2444 {
{
#[allow(unused_mut)]
let mut object_2447 = array_2445.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_details(&mut object_2447, item_2446)?;
object_2447.finish();
}
}
array_2445.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_logging_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketLoggingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2448) = &input.destination_bucket_name {
object
.key("DestinationBucketName")
.string(var_2448.as_str());
}
if let Some(var_2449) = &input.log_file_prefix {
object.key("LogFilePrefix").string(var_2449.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_website_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketWebsiteConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2450) = &input.error_document {
object.key("ErrorDocument").string(var_2450.as_str());
}
if let Some(var_2451) = &input.index_document_suffix {
object.key("IndexDocumentSuffix").string(var_2451.as_str());
}
if let Some(var_2452) = &input.redirect_all_requests_to {
#[allow(unused_mut)]
let mut object_2453 = object.key("RedirectAllRequestsTo").start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_website_configuration_redirect_to(&mut object_2453, var_2452)?;
object_2453.finish();
}
if let Some(var_2454) = &input.routing_rules {
let mut array_2455 = object.key("RoutingRules").start_array();
for item_2456 in var_2454 {
{
#[allow(unused_mut)]
let mut object_2457 = array_2455.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_website_configuration_routing_rule(&mut object_2457, item_2456)?;
object_2457.finish();
}
}
array_2455.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_notification_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketNotificationConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2458) = &input.configurations {
let mut array_2459 = object.key("Configurations").start_array();
for item_2460 in var_2458 {
{
#[allow(unused_mut)]
let mut object_2461 = array_2459.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_notification_configuration_detail(&mut object_2461, item_2460)?;
object_2461.finish();
}
}
array_2459.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_bucket_versioning_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketBucketVersioningConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.is_mfa_delete_enabled {
object
.key("IsMfaDeleteEnabled")
.boolean(input.is_mfa_delete_enabled);
}
if let Some(var_2462) = &input.status {
object.key("Status").string(var_2462.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_secrets_manager_secret_rotation_rules(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsSecretsManagerSecretRotationRules,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.automatically_after_days != 0 {
object.key("AutomaticallyAfterDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.automatically_after_days).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_iam_access_key_session_context(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsIamAccessKeySessionContext,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2463) = &input.attributes {
#[allow(unused_mut)]
let mut object_2464 = object.key("Attributes").start_object();
crate::json_ser::serialize_structure_crate_model_aws_iam_access_key_session_context_attributes(&mut object_2464, var_2463)?;
object_2464.finish();
}
if let Some(var_2465) = &input.session_issuer {
#[allow(unused_mut)]
let mut object_2466 = object.key("SessionIssuer").start_object();
crate::json_ser::serialize_structure_crate_model_aws_iam_access_key_session_context_session_issuer(&mut object_2466, var_2465)?;
object_2466.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_iam_attached_managed_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsIamAttachedManagedPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2467) = &input.policy_name {
object.key("PolicyName").string(var_2467.as_str());
}
if let Some(var_2468) = &input.policy_arn {
object.key("PolicyArn").string(var_2468.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_iam_permissions_boundary(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsIamPermissionsBoundary,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2469) = &input.permissions_boundary_arn {
object
.key("PermissionsBoundaryArn")
.string(var_2469.as_str());
}
if let Some(var_2470) = &input.permissions_boundary_type {
object
.key("PermissionsBoundaryType")
.string(var_2470.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_iam_user_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsIamUserPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2471) = &input.policy_name {
object.key("PolicyName").string(var_2471.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_iam_policy_version(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsIamPolicyVersion,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2472) = &input.version_id {
object.key("VersionId").string(var_2472.as_str());
}
if input.is_default_version {
object
.key("IsDefaultVersion")
.boolean(input.is_default_version);
}
if let Some(var_2473) = &input.create_date {
object.key("CreateDate").string(var_2473.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_api_gateway_v2_route_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsApiGatewayV2RouteSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.detailed_metrics_enabled {
object
.key("DetailedMetricsEnabled")
.boolean(input.detailed_metrics_enabled);
}
if let Some(var_2474) = &input.logging_level {
object.key("LoggingLevel").string(var_2474.as_str());
}
if input.data_trace_enabled {
object
.key("DataTraceEnabled")
.boolean(input.data_trace_enabled);
}
if input.throttling_burst_limit != 0 {
object.key("ThrottlingBurstLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.throttling_burst_limit).into()),
);
}
if input.throttling_rate_limit != 0.0 {
object.key("ThrottlingRateLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.throttling_rate_limit).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_api_gateway_access_log_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsApiGatewayAccessLogSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2475) = &input.format {
object.key("Format").string(var_2475.as_str());
}
if let Some(var_2476) = &input.destination_arn {
object.key("DestinationArn").string(var_2476.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_cors_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCorsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2477) = &input.allow_origins {
let mut array_2478 = object.key("AllowOrigins").start_array();
for item_2479 in var_2477 {
{
array_2478.value().string(item_2479.as_str());
}
}
array_2478.finish();
}
if input.allow_credentials {
object
.key("AllowCredentials")
.boolean(input.allow_credentials);
}
if let Some(var_2480) = &input.expose_headers {
let mut array_2481 = object.key("ExposeHeaders").start_array();
for item_2482 in var_2480 {
{
array_2481.value().string(item_2482.as_str());
}
}
array_2481.finish();
}
if input.max_age != 0 {
object.key("MaxAge").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_age).into()),
);
}
if let Some(var_2483) = &input.allow_methods {
let mut array_2484 = object.key("AllowMethods").start_array();
for item_2485 in var_2483 {
{
array_2484.value().string(item_2485.as_str());
}
}
array_2484.finish();
}
if let Some(var_2486) = &input.allow_headers {
let mut array_2487 = object.key("AllowHeaders").start_array();
for item_2488 in var_2486 {
{
array_2487.value().string(item_2488.as_str());
}
}
array_2487.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_dynamo_db_table_attribute_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsDynamoDbTableAttributeDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2489) = &input.attribute_name {
object.key("AttributeName").string(var_2489.as_str());
}
if let Some(var_2490) = &input.attribute_type {
object.key("AttributeType").string(var_2490.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_dynamo_db_table_billing_mode_summary(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsDynamoDbTableBillingModeSummary,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2491) = &input.billing_mode {
object.key("BillingMode").string(var_2491.as_str());
}
if let Some(var_2492) = &input.last_update_to_pay_per_request_date_time {
object
.key("LastUpdateToPayPerRequestDateTime")
.string(var_2492.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_dynamo_db_table_global_secondary_index(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsDynamoDbTableGlobalSecondaryIndex,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.backfilling {
object.key("Backfilling").boolean(input.backfilling);
}
if let Some(var_2493) = &input.index_arn {
object.key("IndexArn").string(var_2493.as_str());
}
if let Some(var_2494) = &input.index_name {
object.key("IndexName").string(var_2494.as_str());
}
if input.index_size_bytes != 0 {
object.key("IndexSizeBytes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.index_size_bytes).into()),
);
}
if let Some(var_2495) = &input.index_status {
object.key("IndexStatus").string(var_2495.as_str());
}
if input.item_count != 0 {
object.key("ItemCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.item_count).into()),
);
}
if let Some(var_2496) = &input.key_schema {
let mut array_2497 = object.key("KeySchema").start_array();
for item_2498 in var_2496 {
{
#[allow(unused_mut)]
let mut object_2499 = array_2497.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_key_schema(
&mut object_2499,
item_2498,
)?;
object_2499.finish();
}
}
array_2497.finish();
}
if let Some(var_2500) = &input.projection {
#[allow(unused_mut)]
let mut object_2501 = object.key("Projection").start_object();
crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_projection(
&mut object_2501,
var_2500,
)?;
object_2501.finish();
}
if let Some(var_2502) = &input.provisioned_throughput {
#[allow(unused_mut)]
let mut object_2503 = object.key("ProvisionedThroughput").start_object();
crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_provisioned_throughput(&mut object_2503, var_2502)?;
object_2503.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_dynamo_db_table_key_schema(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsDynamoDbTableKeySchema,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2504) = &input.attribute_name {
object.key("AttributeName").string(var_2504.as_str());
}
if let Some(var_2505) = &input.key_type {
object.key("KeyType").string(var_2505.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_dynamo_db_table_local_secondary_index(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsDynamoDbTableLocalSecondaryIndex,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2506) = &input.index_arn {
object.key("IndexArn").string(var_2506.as_str());
}
if let Some(var_2507) = &input.index_name {
object.key("IndexName").string(var_2507.as_str());
}
if let Some(var_2508) = &input.key_schema {
let mut array_2509 = object.key("KeySchema").start_array();
for item_2510 in var_2508 {
{
#[allow(unused_mut)]
let mut object_2511 = array_2509.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_key_schema(
&mut object_2511,
item_2510,
)?;
object_2511.finish();
}
}
array_2509.finish();
}
if let Some(var_2512) = &input.projection {
#[allow(unused_mut)]
let mut object_2513 = object.key("Projection").start_object();
crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_projection(
&mut object_2513,
var_2512,
)?;
object_2513.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_dynamo_db_table_provisioned_throughput(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsDynamoDbTableProvisionedThroughput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2514) = &input.last_decrease_date_time {
object.key("LastDecreaseDateTime").string(var_2514.as_str());
}
if let Some(var_2515) = &input.last_increase_date_time {
object.key("LastIncreaseDateTime").string(var_2515.as_str());
}
if input.number_of_decreases_today != 0 {
object.key("NumberOfDecreasesToday").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.number_of_decreases_today).into()),
);
}
if input.read_capacity_units != 0 {
object.key("ReadCapacityUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.read_capacity_units).into()),
);
}
if input.write_capacity_units != 0 {
object.key("WriteCapacityUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.write_capacity_units).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_dynamo_db_table_replica(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsDynamoDbTableReplica,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2516) = &input.global_secondary_indexes {
let mut array_2517 = object.key("GlobalSecondaryIndexes").start_array();
for item_2518 in var_2516 {
{
#[allow(unused_mut)]
let mut object_2519 = array_2517.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_replica_global_secondary_index(&mut object_2519, item_2518)?;
object_2519.finish();
}
}
array_2517.finish();
}
if let Some(var_2520) = &input.kms_master_key_id {
object.key("KmsMasterKeyId").string(var_2520.as_str());
}
if let Some(var_2521) = &input.provisioned_throughput_override {
#[allow(unused_mut)]
let mut object_2522 = object.key("ProvisionedThroughputOverride").start_object();
crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_provisioned_throughput_override(&mut object_2522, var_2521)?;
object_2522.finish();
}
if let Some(var_2523) = &input.region_name {
object.key("RegionName").string(var_2523.as_str());
}
if let Some(var_2524) = &input.replica_status {
object.key("ReplicaStatus").string(var_2524.as_str());
}
if let Some(var_2525) = &input.replica_status_description {
object
.key("ReplicaStatusDescription")
.string(var_2525.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_dynamo_db_table_restore_summary(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsDynamoDbTableRestoreSummary,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2526) = &input.source_backup_arn {
object.key("SourceBackupArn").string(var_2526.as_str());
}
if let Some(var_2527) = &input.source_table_arn {
object.key("SourceTableArn").string(var_2527.as_str());
}
if let Some(var_2528) = &input.restore_date_time {
object.key("RestoreDateTime").string(var_2528.as_str());
}
if input.restore_in_progress {
object
.key("RestoreInProgress")
.boolean(input.restore_in_progress);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_dynamo_db_table_sse_description(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsDynamoDbTableSseDescription,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2529) = &input.inaccessible_encryption_date_time {
object
.key("InaccessibleEncryptionDateTime")
.string(var_2529.as_str());
}
if let Some(var_2530) = &input.status {
object.key("Status").string(var_2530.as_str());
}
if let Some(var_2531) = &input.sse_type {
object.key("SseType").string(var_2531.as_str());
}
if let Some(var_2532) = &input.kms_master_key_arn {
object.key("KmsMasterKeyArn").string(var_2532.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_dynamo_db_table_stream_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsDynamoDbTableStreamSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.stream_enabled {
object.key("StreamEnabled").boolean(input.stream_enabled);
}
if let Some(var_2533) = &input.stream_view_type {
object.key("StreamViewType").string(var_2533.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_api_gateway_method_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsApiGatewayMethodSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.metrics_enabled {
object.key("MetricsEnabled").boolean(input.metrics_enabled);
}
if let Some(var_2534) = &input.logging_level {
object.key("LoggingLevel").string(var_2534.as_str());
}
if input.data_trace_enabled {
object
.key("DataTraceEnabled")
.boolean(input.data_trace_enabled);
}
if input.throttling_burst_limit != 0 {
object.key("ThrottlingBurstLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.throttling_burst_limit).into()),
);
}
if input.throttling_rate_limit != 0.0 {
object.key("ThrottlingRateLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.throttling_rate_limit).into()),
);
}
if input.caching_enabled {
object.key("CachingEnabled").boolean(input.caching_enabled);
}
if input.cache_ttl_in_seconds != 0 {
object.key("CacheTtlInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.cache_ttl_in_seconds).into()),
);
}
if input.cache_data_encrypted {
object
.key("CacheDataEncrypted")
.boolean(input.cache_data_encrypted);
}
if input.require_authorization_for_cache_control {
object
.key("RequireAuthorizationForCacheControl")
.boolean(input.require_authorization_for_cache_control);
}
if let Some(var_2535) = &input.unauthorized_cache_control_header_strategy {
object
.key("UnauthorizedCacheControlHeaderStrategy")
.string(var_2535.as_str());
}
if let Some(var_2536) = &input.http_method {
object.key("HttpMethod").string(var_2536.as_str());
}
if let Some(var_2537) = &input.resource_path {
object.key("ResourcePath").string(var_2537.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_api_gateway_canary_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsApiGatewayCanarySettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.percent_traffic != 0.0 {
object.key("PercentTraffic").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.percent_traffic).into()),
);
}
if let Some(var_2538) = &input.deployment_id {
object.key("DeploymentId").string(var_2538.as_str());
}
if let Some(var_2539) = &input.stage_variable_overrides {
#[allow(unused_mut)]
let mut object_2540 = object.key("StageVariableOverrides").start_object();
for (key_2541, value_2542) in var_2539 {
{
object_2540
.key(key_2541.as_str())
.string(value_2542.as_str());
}
}
object_2540.finish();
}
if input.use_stage_cache {
object.key("UseStageCache").boolean(input.use_stage_cache);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_api_gateway_endpoint_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsApiGatewayEndpointConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2543) = &input.types {
let mut array_2544 = object.key("Types").start_array();
for item_2545 in var_2543 {
{
array_2544.value().string(item_2545.as_str());
}
}
array_2544.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ssm_patch(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsSsmPatch,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2546) = &input.compliance_summary {
#[allow(unused_mut)]
let mut object_2547 = object.key("ComplianceSummary").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ssm_compliance_summary(
&mut object_2547,
var_2546,
)?;
object_2547.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_certificate_manager_certificate_domain_validation_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCertificateManagerCertificateDomainValidationOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2548) = &input.domain_name {
object.key("DomainName").string(var_2548.as_str());
}
if let Some(var_2549) = &input.resource_record {
#[allow(unused_mut)]
let mut object_2550 = object.key("ResourceRecord").start_object();
crate::json_ser::serialize_structure_crate_model_aws_certificate_manager_certificate_resource_record(&mut object_2550, var_2549)?;
object_2550.finish();
}
if let Some(var_2551) = &input.validation_domain {
object.key("ValidationDomain").string(var_2551.as_str());
}
if let Some(var_2552) = &input.validation_emails {
let mut array_2553 = object.key("ValidationEmails").start_array();
for item_2554 in var_2552 {
{
array_2553.value().string(item_2554.as_str());
}
}
array_2553.finish();
}
if let Some(var_2555) = &input.validation_method {
object.key("ValidationMethod").string(var_2555.as_str());
}
if let Some(var_2556) = &input.validation_status {
object.key("ValidationStatus").string(var_2556.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_certificate_manager_certificate_extended_key_usage(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCertificateManagerCertificateExtendedKeyUsage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2557) = &input.name {
object.key("Name").string(var_2557.as_str());
}
if let Some(var_2558) = &input.o_id {
object.key("OId").string(var_2558.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_certificate_manager_certificate_key_usage(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCertificateManagerCertificateKeyUsage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2559) = &input.name {
object.key("Name").string(var_2559.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_certificate_manager_certificate_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCertificateManagerCertificateOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2560) = &input.certificate_transparency_logging_preference {
object
.key("CertificateTransparencyLoggingPreference")
.string(var_2560.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_certificate_manager_certificate_renewal_summary(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCertificateManagerCertificateRenewalSummary,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2561) = &input.domain_validation_options {
let mut array_2562 = object.key("DomainValidationOptions").start_array();
for item_2563 in var_2561 {
{
#[allow(unused_mut)]
let mut object_2564 = array_2562.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_certificate_manager_certificate_domain_validation_option(&mut object_2564, item_2563)?;
object_2564.finish();
}
}
array_2562.finish();
}
if let Some(var_2565) = &input.renewal_status {
object.key("RenewalStatus").string(var_2565.as_str());
}
if let Some(var_2566) = &input.renewal_status_reason {
object.key("RenewalStatusReason").string(var_2566.as_str());
}
if let Some(var_2567) = &input.updated_at {
object.key("UpdatedAt").string(var_2567.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_redshift_cluster_cluster_node(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRedshiftClusterClusterNode,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2568) = &input.node_role {
object.key("NodeRole").string(var_2568.as_str());
}
if let Some(var_2569) = &input.private_ip_address {
object.key("PrivateIpAddress").string(var_2569.as_str());
}
if let Some(var_2570) = &input.public_ip_address {
object.key("PublicIpAddress").string(var_2570.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_redshift_cluster_cluster_parameter_group(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRedshiftClusterClusterParameterGroup,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2571) = &input.cluster_parameter_status_list {
let mut array_2572 = object.key("ClusterParameterStatusList").start_array();
for item_2573 in var_2571 {
{
#[allow(unused_mut)]
let mut object_2574 = array_2572.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_cluster_parameter_status(&mut object_2574, item_2573)?;
object_2574.finish();
}
}
array_2572.finish();
}
if let Some(var_2575) = &input.parameter_apply_status {
object.key("ParameterApplyStatus").string(var_2575.as_str());
}
if let Some(var_2576) = &input.parameter_group_name {
object.key("ParameterGroupName").string(var_2576.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_redshift_cluster_cluster_security_group(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRedshiftClusterClusterSecurityGroup,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2577) = &input.cluster_security_group_name {
object
.key("ClusterSecurityGroupName")
.string(var_2577.as_str());
}
if let Some(var_2578) = &input.status {
object.key("Status").string(var_2578.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_redshift_cluster_cluster_snapshot_copy_status(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRedshiftClusterClusterSnapshotCopyStatus,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2579) = &input.destination_region {
object.key("DestinationRegion").string(var_2579.as_str());
}
if input.manual_snapshot_retention_period != 0 {
object.key("ManualSnapshotRetentionPeriod").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.manual_snapshot_retention_period).into()),
);
}
if input.retention_period != 0 {
object.key("RetentionPeriod").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.retention_period).into()),
);
}
if let Some(var_2580) = &input.snapshot_copy_grant_name {
object
.key("SnapshotCopyGrantName")
.string(var_2580.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_redshift_cluster_deferred_maintenance_window(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRedshiftClusterDeferredMaintenanceWindow,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2581) = &input.defer_maintenance_end_time {
object
.key("DeferMaintenanceEndTime")
.string(var_2581.as_str());
}
if let Some(var_2582) = &input.defer_maintenance_identifier {
object
.key("DeferMaintenanceIdentifier")
.string(var_2582.as_str());
}
if let Some(var_2583) = &input.defer_maintenance_start_time {
object
.key("DeferMaintenanceStartTime")
.string(var_2583.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_redshift_cluster_elastic_ip_status(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRedshiftClusterElasticIpStatus,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2584) = &input.elastic_ip {
object.key("ElasticIp").string(var_2584.as_str());
}
if let Some(var_2585) = &input.status {
object.key("Status").string(var_2585.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_redshift_cluster_endpoint(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRedshiftClusterEndpoint,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2586) = &input.address {
object.key("Address").string(var_2586.as_str());
}
if input.port != 0 {
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_redshift_cluster_hsm_status(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRedshiftClusterHsmStatus,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2587) = &input.hsm_client_certificate_identifier {
object
.key("HsmClientCertificateIdentifier")
.string(var_2587.as_str());
}
if let Some(var_2588) = &input.hsm_configuration_identifier {
object
.key("HsmConfigurationIdentifier")
.string(var_2588.as_str());
}
if let Some(var_2589) = &input.status {
object.key("Status").string(var_2589.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_redshift_cluster_iam_role(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRedshiftClusterIamRole,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2590) = &input.apply_status {
object.key("ApplyStatus").string(var_2590.as_str());
}
if let Some(var_2591) = &input.iam_role_arn {
object.key("IamRoleArn").string(var_2591.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_redshift_cluster_pending_modified_values(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRedshiftClusterPendingModifiedValues,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.automated_snapshot_retention_period != 0 {
object.key("AutomatedSnapshotRetentionPeriod").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.automated_snapshot_retention_period).into()),
);
}
if let Some(var_2592) = &input.cluster_identifier {
object.key("ClusterIdentifier").string(var_2592.as_str());
}
if let Some(var_2593) = &input.cluster_type {
object.key("ClusterType").string(var_2593.as_str());
}
if let Some(var_2594) = &input.cluster_version {
object.key("ClusterVersion").string(var_2594.as_str());
}
if let Some(var_2595) = &input.encryption_type {
object.key("EncryptionType").string(var_2595.as_str());
}
if input.enhanced_vpc_routing {
object
.key("EnhancedVpcRouting")
.boolean(input.enhanced_vpc_routing);
}
if let Some(var_2596) = &input.maintenance_track_name {
object.key("MaintenanceTrackName").string(var_2596.as_str());
}
if let Some(var_2597) = &input.master_user_password {
object.key("MasterUserPassword").string(var_2597.as_str());
}
if let Some(var_2598) = &input.node_type {
object.key("NodeType").string(var_2598.as_str());
}
if input.number_of_nodes != 0 {
object.key("NumberOfNodes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.number_of_nodes).into()),
);
}
if input.publicly_accessible {
object
.key("PubliclyAccessible")
.boolean(input.publicly_accessible);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_redshift_cluster_resize_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRedshiftClusterResizeInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.allow_cancel_resize {
object
.key("AllowCancelResize")
.boolean(input.allow_cancel_resize);
}
if let Some(var_2599) = &input.resize_type {
object.key("ResizeType").string(var_2599.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_redshift_cluster_restore_status(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRedshiftClusterRestoreStatus,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.current_restore_rate_in_mega_bytes_per_second != 0.0 {
object.key("CurrentRestoreRateInMegaBytesPerSecond").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float(
(input.current_restore_rate_in_mega_bytes_per_second).into(),
),
);
}
if input.elapsed_time_in_seconds != 0 {
object.key("ElapsedTimeInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.elapsed_time_in_seconds).into()),
);
}
if input.estimated_time_to_completion_in_seconds != 0 {
object.key("EstimatedTimeToCompletionInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt(
(input.estimated_time_to_completion_in_seconds).into(),
),
);
}
if input.progress_in_mega_bytes != 0 {
object.key("ProgressInMegaBytes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.progress_in_mega_bytes).into()),
);
}
if input.snapshot_size_in_mega_bytes != 0 {
object.key("SnapshotSizeInMegaBytes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.snapshot_size_in_mega_bytes).into()),
);
}
if let Some(var_2600) = &input.status {
object.key("Status").string(var_2600.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_redshift_cluster_vpc_security_group(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRedshiftClusterVpcSecurityGroup,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2601) = &input.status {
object.key("Status").string(var_2601.as_str());
}
if let Some(var_2602) = &input.vpc_security_group_id {
object.key("VpcSecurityGroupId").string(var_2602.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_redshift_cluster_logging_status(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRedshiftClusterLoggingStatus,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2603) = &input.bucket_name {
object.key("BucketName").string(var_2603.as_str());
}
if let Some(var_2604) = &input.last_failure_message {
object.key("LastFailureMessage").string(var_2604.as_str());
}
if let Some(var_2605) = &input.last_failure_time {
object.key("LastFailureTime").string(var_2605.as_str());
}
if let Some(var_2606) = &input.last_successful_delivery_time {
object
.key("LastSuccessfulDeliveryTime")
.string(var_2606.as_str());
}
if input.logging_enabled {
object.key("LoggingEnabled").boolean(input.logging_enabled);
}
if let Some(var_2607) = &input.s3_key_prefix {
object.key("S3KeyPrefix").string(var_2607.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elb_load_balancer_backend_server_description(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElbLoadBalancerBackendServerDescription,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.instance_port != 0 {
object.key("InstancePort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.instance_port).into()),
);
}
if let Some(var_2608) = &input.policy_names {
let mut array_2609 = object.key("PolicyNames").start_array();
for item_2610 in var_2608 {
{
array_2609.value().string(item_2610.as_str());
}
}
array_2609.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elb_load_balancer_health_check(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElbLoadBalancerHealthCheck,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.healthy_threshold != 0 {
object.key("HealthyThreshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.healthy_threshold).into()),
);
}
if input.interval != 0 {
object.key("Interval").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.interval).into()),
);
}
if let Some(var_2611) = &input.target {
object.key("Target").string(var_2611.as_str());
}
if input.timeout != 0 {
object.key("Timeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.timeout).into()),
);
}
if input.unhealthy_threshold != 0 {
object.key("UnhealthyThreshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.unhealthy_threshold).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elb_load_balancer_instance(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElbLoadBalancerInstance,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2612) = &input.instance_id {
object.key("InstanceId").string(var_2612.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elb_load_balancer_listener_description(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElbLoadBalancerListenerDescription,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2613) = &input.listener {
#[allow(unused_mut)]
let mut object_2614 = object.key("Listener").start_object();
crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_listener(
&mut object_2614,
var_2613,
)?;
object_2614.finish();
}
if let Some(var_2615) = &input.policy_names {
let mut array_2616 = object.key("PolicyNames").start_array();
for item_2617 in var_2615 {
{
array_2616.value().string(item_2617.as_str());
}
}
array_2616.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elb_load_balancer_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElbLoadBalancerAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2618) = &input.access_log {
#[allow(unused_mut)]
let mut object_2619 = object.key("AccessLog").start_object();
crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_access_log(
&mut object_2619,
var_2618,
)?;
object_2619.finish();
}
if let Some(var_2620) = &input.connection_draining {
#[allow(unused_mut)]
let mut object_2621 = object.key("ConnectionDraining").start_object();
crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_connection_draining(
&mut object_2621,
var_2620,
)?;
object_2621.finish();
}
if let Some(var_2622) = &input.connection_settings {
#[allow(unused_mut)]
let mut object_2623 = object.key("ConnectionSettings").start_object();
crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_connection_settings(
&mut object_2623,
var_2622,
)?;
object_2623.finish();
}
if let Some(var_2624) = &input.cross_zone_load_balancing {
#[allow(unused_mut)]
let mut object_2625 = object.key("CrossZoneLoadBalancing").start_object();
crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_cross_zone_load_balancing(&mut object_2625, var_2624)?;
object_2625.finish();
}
if let Some(var_2626) = &input.additional_attributes {
let mut array_2627 = object.key("AdditionalAttributes").start_array();
for item_2628 in var_2626 {
{
#[allow(unused_mut)]
let mut object_2629 = array_2627.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_additional_attribute(&mut object_2629, item_2628)?;
object_2629.finish();
}
}
array_2627.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elb_load_balancer_policies(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElbLoadBalancerPolicies,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2630) = &input.app_cookie_stickiness_policies {
let mut array_2631 = object.key("AppCookieStickinessPolicies").start_array();
for item_2632 in var_2630 {
{
#[allow(unused_mut)]
let mut object_2633 = array_2631.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_elb_app_cookie_stickiness_policy(&mut object_2633, item_2632)?;
object_2633.finish();
}
}
array_2631.finish();
}
if let Some(var_2634) = &input.lb_cookie_stickiness_policies {
let mut array_2635 = object.key("LbCookieStickinessPolicies").start_array();
for item_2636 in var_2634 {
{
#[allow(unused_mut)]
let mut object_2637 = array_2635.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_elb_lb_cookie_stickiness_policy(&mut object_2637, item_2636)?;
object_2637.finish();
}
}
array_2635.finish();
}
if let Some(var_2638) = &input.other_policies {
let mut array_2639 = object.key("OtherPolicies").start_array();
for item_2640 in var_2638 {
{
array_2639.value().string(item_2640.as_str());
}
}
array_2639.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elb_load_balancer_source_security_group(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElbLoadBalancerSourceSecurityGroup,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2641) = &input.group_name {
object.key("GroupName").string(var_2641.as_str());
}
if let Some(var_2642) = &input.owner_alias {
object.key("OwnerAlias").string(var_2642.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_iam_group_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsIamGroupPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2643) = &input.policy_name {
object.key("PolicyName").string(var_2643.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_iam_instance_profile(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsIamInstanceProfile,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2644) = &input.arn {
object.key("Arn").string(var_2644.as_str());
}
if let Some(var_2645) = &input.create_date {
object.key("CreateDate").string(var_2645.as_str());
}
if let Some(var_2646) = &input.instance_profile_id {
object.key("InstanceProfileId").string(var_2646.as_str());
}
if let Some(var_2647) = &input.instance_profile_name {
object.key("InstanceProfileName").string(var_2647.as_str());
}
if let Some(var_2648) = &input.path {
object.key("Path").string(var_2648.as_str());
}
if let Some(var_2649) = &input.roles {
let mut array_2650 = object.key("Roles").start_array();
for item_2651 in var_2649 {
{
#[allow(unused_mut)]
let mut object_2652 = array_2650.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_iam_instance_profile_role(
&mut object_2652,
item_2651,
)?;
object_2652.finish();
}
}
array_2650.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_iam_role_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsIamRolePolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2653) = &input.policy_name {
object.key("PolicyName").string(var_2653.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_lambda_function_code(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsLambdaFunctionCode,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2654) = &input.s3_bucket {
object.key("S3Bucket").string(var_2654.as_str());
}
if let Some(var_2655) = &input.s3_key {
object.key("S3Key").string(var_2655.as_str());
}
if let Some(var_2656) = &input.s3_object_version {
object.key("S3ObjectVersion").string(var_2656.as_str());
}
if let Some(var_2657) = &input.zip_file {
object.key("ZipFile").string(var_2657.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_lambda_function_dead_letter_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsLambdaFunctionDeadLetterConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2658) = &input.target_arn {
object.key("TargetArn").string(var_2658.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_lambda_function_environment(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsLambdaFunctionEnvironment,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2659) = &input.variables {
#[allow(unused_mut)]
let mut object_2660 = object.key("Variables").start_object();
for (key_2661, value_2662) in var_2659 {
{
object_2660
.key(key_2661.as_str())
.string(value_2662.as_str());
}
}
object_2660.finish();
}
if let Some(var_2663) = &input.error {
#[allow(unused_mut)]
let mut object_2664 = object.key("Error").start_object();
crate::json_ser::serialize_structure_crate_model_aws_lambda_function_environment_error(
&mut object_2664,
var_2663,
)?;
object_2664.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_lambda_function_layer(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsLambdaFunctionLayer,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2665) = &input.arn {
object.key("Arn").string(var_2665.as_str());
}
if input.code_size != 0 {
object.key("CodeSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.code_size).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_lambda_function_tracing_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsLambdaFunctionTracingConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2666) = &input.mode {
object.key("Mode").string(var_2666.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_lambda_function_vpc_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsLambdaFunctionVpcConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2667) = &input.security_group_ids {
let mut array_2668 = object.key("SecurityGroupIds").start_array();
for item_2669 in var_2667 {
{
array_2668.value().string(item_2669.as_str());
}
}
array_2668.finish();
}
if let Some(var_2670) = &input.subnet_ids {
let mut array_2671 = object.key("SubnetIds").start_array();
for item_2672 in var_2670 {
{
array_2671.value().string(item_2672.as_str());
}
}
array_2671.finish();
}
if let Some(var_2673) = &input.vpc_id {
object.key("VpcId").string(var_2673.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_rds_db_instance_associated_role(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRdsDbInstanceAssociatedRole,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2674) = &input.role_arn {
object.key("RoleArn").string(var_2674.as_str());
}
if let Some(var_2675) = &input.feature_name {
object.key("FeatureName").string(var_2675.as_str());
}
if let Some(var_2676) = &input.status {
object.key("Status").string(var_2676.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_rds_db_instance_endpoint(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRdsDbInstanceEndpoint,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2677) = &input.address {
object.key("Address").string(var_2677.as_str());
}
if input.port != 0 {
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port).into()),
);
}
if let Some(var_2678) = &input.hosted_zone_id {
object.key("HostedZoneId").string(var_2678.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_rds_db_instance_vpc_security_group(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRdsDbInstanceVpcSecurityGroup,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2679) = &input.vpc_security_group_id {
object.key("VpcSecurityGroupId").string(var_2679.as_str());
}
if let Some(var_2680) = &input.status {
object.key("Status").string(var_2680.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_rds_db_parameter_group(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRdsDbParameterGroup,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2681) = &input.db_parameter_group_name {
object.key("DbParameterGroupName").string(var_2681.as_str());
}
if let Some(var_2682) = &input.parameter_apply_status {
object.key("ParameterApplyStatus").string(var_2682.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_rds_db_subnet_group(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRdsDbSubnetGroup,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2683) = &input.db_subnet_group_name {
object.key("DbSubnetGroupName").string(var_2683.as_str());
}
if let Some(var_2684) = &input.db_subnet_group_description {
object
.key("DbSubnetGroupDescription")
.string(var_2684.as_str());
}
if let Some(var_2685) = &input.vpc_id {
object.key("VpcId").string(var_2685.as_str());
}
if let Some(var_2686) = &input.subnet_group_status {
object.key("SubnetGroupStatus").string(var_2686.as_str());
}
if let Some(var_2687) = &input.subnets {
let mut array_2688 = object.key("Subnets").start_array();
for item_2689 in var_2687 {
{
#[allow(unused_mut)]
let mut object_2690 = array_2688.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_subnet_group_subnet(
&mut object_2690,
item_2689,
)?;
object_2690.finish();
}
}
array_2688.finish();
}
if let Some(var_2691) = &input.db_subnet_group_arn {
object.key("DbSubnetGroupArn").string(var_2691.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_rds_db_pending_modified_values(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRdsDbPendingModifiedValues,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2692) = &input.db_instance_class {
object.key("DbInstanceClass").string(var_2692.as_str());
}
if input.allocated_storage != 0 {
object.key("AllocatedStorage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.allocated_storage).into()),
);
}
if let Some(var_2693) = &input.master_user_password {
object.key("MasterUserPassword").string(var_2693.as_str());
}
if input.port != 0 {
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port).into()),
);
}
if input.backup_retention_period != 0 {
object.key("BackupRetentionPeriod").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.backup_retention_period).into()),
);
}
if input.multi_az {
object.key("MultiAZ").boolean(input.multi_az);
}
if let Some(var_2694) = &input.engine_version {
object.key("EngineVersion").string(var_2694.as_str());
}
if let Some(var_2695) = &input.license_model {
object.key("LicenseModel").string(var_2695.as_str());
}
if input.iops != 0 {
object.key("Iops").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.iops).into()),
);
}
if let Some(var_2696) = &input.db_instance_identifier {
object.key("DbInstanceIdentifier").string(var_2696.as_str());
}
if let Some(var_2697) = &input.storage_type {
object.key("StorageType").string(var_2697.as_str());
}
if let Some(var_2698) = &input.ca_certificate_identifier {
object
.key("CaCertificateIdentifier")
.string(var_2698.as_str());
}
if let Some(var_2699) = &input.db_subnet_group_name {
object.key("DbSubnetGroupName").string(var_2699.as_str());
}
if let Some(var_2700) = &input.pending_cloud_watch_logs_exports {
#[allow(unused_mut)]
let mut object_2701 = object.key("PendingCloudWatchLogsExports").start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_pending_cloud_watch_logs_exports(
&mut object_2701,
var_2700,
)?;
object_2701.finish();
}
if let Some(var_2702) = &input.processor_features {
let mut array_2703 = object.key("ProcessorFeatures").start_array();
for item_2704 in var_2702 {
{
#[allow(unused_mut)]
let mut object_2705 = array_2703.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_processor_feature(
&mut object_2705,
item_2704,
)?;
object_2705.finish();
}
}
array_2703.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_rds_db_option_group_membership(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRdsDbOptionGroupMembership,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2706) = &input.option_group_name {
object.key("OptionGroupName").string(var_2706.as_str());
}
if let Some(var_2707) = &input.status {
object.key("Status").string(var_2707.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_rds_db_status_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRdsDbStatusInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2708) = &input.status_type {
object.key("StatusType").string(var_2708.as_str());
}
if input.normal {
object.key("Normal").boolean(input.normal);
}
if let Some(var_2709) = &input.status {
object.key("Status").string(var_2709.as_str());
}
if let Some(var_2710) = &input.message {
object.key("Message").string(var_2710.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_rds_db_domain_membership(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRdsDbDomainMembership,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2711) = &input.domain {
object.key("Domain").string(var_2711.as_str());
}
if let Some(var_2712) = &input.status {
object.key("Status").string(var_2712.as_str());
}
if let Some(var_2713) = &input.fqdn {
object.key("Fqdn").string(var_2713.as_str());
}
if let Some(var_2714) = &input.iam_role_name {
object.key("IamRoleName").string(var_2714.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_rds_db_processor_feature(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRdsDbProcessorFeature,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2715) = &input.name {
object.key("Name").string(var_2715.as_str());
}
if let Some(var_2716) = &input.value {
object.key("Value").string(var_2716.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_sns_topic_subscription(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsSnsTopicSubscription,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2717) = &input.endpoint {
object.key("Endpoint").string(var_2717.as_str());
}
if let Some(var_2718) = &input.protocol {
object.key("Protocol").string(var_2718.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_waf_web_acl_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafWebAclRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2719) = &input.action {
#[allow(unused_mut)]
let mut object_2720 = object.key("Action").start_object();
crate::json_ser::serialize_structure_crate_model_waf_action(&mut object_2720, var_2719)?;
object_2720.finish();
}
if let Some(var_2721) = &input.excluded_rules {
let mut array_2722 = object.key("ExcludedRules").start_array();
for item_2723 in var_2721 {
{
#[allow(unused_mut)]
let mut object_2724 = array_2722.value().start_object();
crate::json_ser::serialize_structure_crate_model_waf_excluded_rule(
&mut object_2724,
item_2723,
)?;
object_2724.finish();
}
}
array_2722.finish();
}
if let Some(var_2725) = &input.override_action {
#[allow(unused_mut)]
let mut object_2726 = object.key("OverrideAction").start_object();
crate::json_ser::serialize_structure_crate_model_waf_override_action(
&mut object_2726,
var_2725,
)?;
object_2726.finish();
}
if input.priority != 0 {
object.key("Priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.priority).into()),
);
}
if let Some(var_2727) = &input.rule_id {
object.key("RuleId").string(var_2727.as_str());
}
if let Some(var_2728) = &input.r#type {
object.key("Type").string(var_2728.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_rds_db_cluster_associated_role(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRdsDbClusterAssociatedRole,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2729) = &input.role_arn {
object.key("RoleArn").string(var_2729.as_str());
}
if let Some(var_2730) = &input.status {
object.key("Status").string(var_2730.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_rds_db_cluster_option_group_membership(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRdsDbClusterOptionGroupMembership,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2731) = &input.db_cluster_option_group_name {
object
.key("DbClusterOptionGroupName")
.string(var_2731.as_str());
}
if let Some(var_2732) = &input.status {
object.key("Status").string(var_2732.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_rds_db_cluster_member(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRdsDbClusterMember,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.is_cluster_writer {
object
.key("IsClusterWriter")
.boolean(input.is_cluster_writer);
}
if input.promotion_tier != 0 {
object.key("PromotionTier").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.promotion_tier).into()),
);
}
if let Some(var_2733) = &input.db_instance_identifier {
object.key("DbInstanceIdentifier").string(var_2733.as_str());
}
if let Some(var_2734) = &input.db_cluster_parameter_group_status {
object
.key("DbClusterParameterGroupStatus")
.string(var_2734.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_cluster_cluster_settings_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsClusterClusterSettingsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2735) = &input.name {
object.key("Name").string(var_2735.as_str());
}
if let Some(var_2736) = &input.value {
object.key("Value").string(var_2736.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_cluster_configuration_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsClusterConfigurationDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2737) = &input.execute_command_configuration {
#[allow(unused_mut)]
let mut object_2738 = object.key("ExecuteCommandConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_cluster_configuration_execute_command_configuration_details(&mut object_2738, var_2737)?;
object_2738.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_cluster_default_capacity_provider_strategy_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsClusterDefaultCapacityProviderStrategyDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.base != 0 {
object.key("Base").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.base).into()),
);
}
if let Some(var_2739) = &input.capacity_provider {
object.key("CapacityProvider").string(var_2739.as_str());
}
if input.weight != 0 {
object.key("Weight").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.weight).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_mount_point(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsMountPoint,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2740) = &input.source_volume {
object.key("SourceVolume").string(var_2740.as_str());
}
if let Some(var_2741) = &input.container_path {
object.key("ContainerPath").string(var_2741.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2742) = &input.command {
let mut array_2743 = object.key("Command").start_array();
for item_2744 in var_2742 {
{
array_2743.value().string(item_2744.as_str());
}
}
array_2743.finish();
}
if input.cpu != 0 {
object.key("Cpu").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.cpu).into()),
);
}
if let Some(var_2745) = &input.depends_on {
let mut array_2746 = object.key("DependsOn").start_array();
for item_2747 in var_2745 {
{
#[allow(unused_mut)]
let mut object_2748 = array_2746.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_depends_on_details(&mut object_2748, item_2747)?;
object_2748.finish();
}
}
array_2746.finish();
}
if input.disable_networking {
object
.key("DisableNetworking")
.boolean(input.disable_networking);
}
if let Some(var_2749) = &input.dns_search_domains {
let mut array_2750 = object.key("DnsSearchDomains").start_array();
for item_2751 in var_2749 {
{
array_2750.value().string(item_2751.as_str());
}
}
array_2750.finish();
}
if let Some(var_2752) = &input.dns_servers {
let mut array_2753 = object.key("DnsServers").start_array();
for item_2754 in var_2752 {
{
array_2753.value().string(item_2754.as_str());
}
}
array_2753.finish();
}
if let Some(var_2755) = &input.docker_labels {
#[allow(unused_mut)]
let mut object_2756 = object.key("DockerLabels").start_object();
for (key_2757, value_2758) in var_2755 {
{
object_2756
.key(key_2757.as_str())
.string(value_2758.as_str());
}
}
object_2756.finish();
}
if let Some(var_2759) = &input.docker_security_options {
let mut array_2760 = object.key("DockerSecurityOptions").start_array();
for item_2761 in var_2759 {
{
array_2760.value().string(item_2761.as_str());
}
}
array_2760.finish();
}
if let Some(var_2762) = &input.entry_point {
let mut array_2763 = object.key("EntryPoint").start_array();
for item_2764 in var_2762 {
{
array_2763.value().string(item_2764.as_str());
}
}
array_2763.finish();
}
if let Some(var_2765) = &input.environment {
let mut array_2766 = object.key("Environment").start_array();
for item_2767 in var_2765 {
{
#[allow(unused_mut)]
let mut object_2768 = array_2766.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_environment_details(&mut object_2768, item_2767)?;
object_2768.finish();
}
}
array_2766.finish();
}
if let Some(var_2769) = &input.environment_files {
let mut array_2770 = object.key("EnvironmentFiles").start_array();
for item_2771 in var_2769 {
{
#[allow(unused_mut)]
let mut object_2772 = array_2770.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_environment_files_details(&mut object_2772, item_2771)?;
object_2772.finish();
}
}
array_2770.finish();
}
if input.essential {
object.key("Essential").boolean(input.essential);
}
if let Some(var_2773) = &input.extra_hosts {
let mut array_2774 = object.key("ExtraHosts").start_array();
for item_2775 in var_2773 {
{
#[allow(unused_mut)]
let mut object_2776 = array_2774.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_extra_hosts_details(&mut object_2776, item_2775)?;
object_2776.finish();
}
}
array_2774.finish();
}
if let Some(var_2777) = &input.firelens_configuration {
#[allow(unused_mut)]
let mut object_2778 = object.key("FirelensConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_firelens_configuration_details(&mut object_2778, var_2777)?;
object_2778.finish();
}
if let Some(var_2779) = &input.health_check {
#[allow(unused_mut)]
let mut object_2780 = object.key("HealthCheck").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_health_check_details(&mut object_2780, var_2779)?;
object_2780.finish();
}
if let Some(var_2781) = &input.hostname {
object.key("Hostname").string(var_2781.as_str());
}
if let Some(var_2782) = &input.image {
object.key("Image").string(var_2782.as_str());
}
if input.interactive {
object.key("Interactive").boolean(input.interactive);
}
if let Some(var_2783) = &input.links {
let mut array_2784 = object.key("Links").start_array();
for item_2785 in var_2783 {
{
array_2784.value().string(item_2785.as_str());
}
}
array_2784.finish();
}
if let Some(var_2786) = &input.linux_parameters {
#[allow(unused_mut)]
let mut object_2787 = object.key("LinuxParameters").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_linux_parameters_details(&mut object_2787, var_2786)?;
object_2787.finish();
}
if let Some(var_2788) = &input.log_configuration {
#[allow(unused_mut)]
let mut object_2789 = object.key("LogConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_log_configuration_details(&mut object_2789, var_2788)?;
object_2789.finish();
}
if input.memory != 0 {
object.key("Memory").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.memory).into()),
);
}
if input.memory_reservation != 0 {
object.key("MemoryReservation").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.memory_reservation).into()),
);
}
if let Some(var_2790) = &input.mount_points {
let mut array_2791 = object.key("MountPoints").start_array();
for item_2792 in var_2790 {
{
#[allow(unused_mut)]
let mut object_2793 = array_2791.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_mount_points_details(&mut object_2793, item_2792)?;
object_2793.finish();
}
}
array_2791.finish();
}
if let Some(var_2794) = &input.name {
object.key("Name").string(var_2794.as_str());
}
if let Some(var_2795) = &input.port_mappings {
let mut array_2796 = object.key("PortMappings").start_array();
for item_2797 in var_2795 {
{
#[allow(unused_mut)]
let mut object_2798 = array_2796.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_port_mappings_details(&mut object_2798, item_2797)?;
object_2798.finish();
}
}
array_2796.finish();
}
if input.privileged {
object.key("Privileged").boolean(input.privileged);
}
if input.pseudo_terminal {
object.key("PseudoTerminal").boolean(input.pseudo_terminal);
}
if input.readonly_root_filesystem {
object
.key("ReadonlyRootFilesystem")
.boolean(input.readonly_root_filesystem);
}
if let Some(var_2799) = &input.repository_credentials {
#[allow(unused_mut)]
let mut object_2800 = object.key("RepositoryCredentials").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_repository_credentials_details(&mut object_2800, var_2799)?;
object_2800.finish();
}
if let Some(var_2801) = &input.resource_requirements {
let mut array_2802 = object.key("ResourceRequirements").start_array();
for item_2803 in var_2801 {
{
#[allow(unused_mut)]
let mut object_2804 = array_2802.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_resource_requirements_details(&mut object_2804, item_2803)?;
object_2804.finish();
}
}
array_2802.finish();
}
if let Some(var_2805) = &input.secrets {
let mut array_2806 = object.key("Secrets").start_array();
for item_2807 in var_2805 {
{
#[allow(unused_mut)]
let mut object_2808 = array_2806.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_secrets_details(&mut object_2808, item_2807)?;
object_2808.finish();
}
}
array_2806.finish();
}
if input.start_timeout != 0 {
object.key("StartTimeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.start_timeout).into()),
);
}
if input.stop_timeout != 0 {
object.key("StopTimeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.stop_timeout).into()),
);
}
if let Some(var_2809) = &input.system_controls {
let mut array_2810 = object.key("SystemControls").start_array();
for item_2811 in var_2809 {
{
#[allow(unused_mut)]
let mut object_2812 = array_2810.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_system_controls_details(&mut object_2812, item_2811)?;
object_2812.finish();
}
}
array_2810.finish();
}
if let Some(var_2813) = &input.ulimits {
let mut array_2814 = object.key("Ulimits").start_array();
for item_2815 in var_2813 {
{
#[allow(unused_mut)]
let mut object_2816 = array_2814.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_ulimits_details(&mut object_2816, item_2815)?;
object_2816.finish();
}
}
array_2814.finish();
}
if let Some(var_2817) = &input.user {
object.key("User").string(var_2817.as_str());
}
if let Some(var_2818) = &input.volumes_from {
let mut array_2819 = object.key("VolumesFrom").start_array();
for item_2820 in var_2818 {
{
#[allow(unused_mut)]
let mut object_2821 = array_2819.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_volumes_from_details(&mut object_2821, item_2820)?;
object_2821.finish();
}
}
array_2819.finish();
}
if let Some(var_2822) = &input.working_directory {
object.key("WorkingDirectory").string(var_2822.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_inference_accelerators_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionInferenceAcceleratorsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2823) = &input.device_name {
object.key("DeviceName").string(var_2823.as_str());
}
if let Some(var_2824) = &input.device_type {
object.key("DeviceType").string(var_2824.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_placement_constraints_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionPlacementConstraintsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2825) = &input.expression {
object.key("Expression").string(var_2825.as_str());
}
if let Some(var_2826) = &input.r#type {
object.key("Type").string(var_2826.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_proxy_configuration_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionProxyConfigurationDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2827) = &input.container_name {
object.key("ContainerName").string(var_2827.as_str());
}
if let Some(var_2828) = &input.proxy_configuration_properties {
let mut array_2829 = object.key("ProxyConfigurationProperties").start_array();
for item_2830 in var_2828 {
{
#[allow(unused_mut)]
let mut object_2831 = array_2829.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_proxy_configuration_proxy_configuration_properties_details(&mut object_2831, item_2830)?;
object_2831.finish();
}
}
array_2829.finish();
}
if let Some(var_2832) = &input.r#type {
object.key("Type").string(var_2832.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_volumes_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionVolumesDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2833) = &input.docker_volume_configuration {
#[allow(unused_mut)]
let mut object_2834 = object.key("DockerVolumeConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_volumes_docker_volume_configuration_details(&mut object_2834, var_2833)?;
object_2834.finish();
}
if let Some(var_2835) = &input.efs_volume_configuration {
#[allow(unused_mut)]
let mut object_2836 = object.key("EfsVolumeConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_volumes_efs_volume_configuration_details(&mut object_2836, var_2835)?;
object_2836.finish();
}
if let Some(var_2837) = &input.host {
#[allow(unused_mut)]
let mut object_2838 = object.key("Host").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_volumes_host_details(&mut object_2838, var_2837)?;
object_2838.finish();
}
if let Some(var_2839) = &input.name {
object.key("Name").string(var_2839.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_volume_mount(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VolumeMount,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2840) = &input.name {
object.key("Name").string(var_2840.as_str());
}
if let Some(var_2841) = &input.mount_path {
object.key("MountPath").string(var_2841.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_service_capacity_provider_strategy_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsServiceCapacityProviderStrategyDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.base != 0 {
object.key("Base").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.base).into()),
);
}
if let Some(var_2842) = &input.capacity_provider {
object.key("CapacityProvider").string(var_2842.as_str());
}
if input.weight != 0 {
object.key("Weight").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.weight).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_service_deployment_configuration_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsServiceDeploymentConfigurationDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2843) = &input.deployment_circuit_breaker {
#[allow(unused_mut)]
let mut object_2844 = object.key("DeploymentCircuitBreaker").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_service_deployment_configuration_deployment_circuit_breaker_details(&mut object_2844, var_2843)?;
object_2844.finish();
}
if input.maximum_percent != 0 {
object.key("MaximumPercent").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.maximum_percent).into()),
);
}
if input.minimum_healthy_percent != 0 {
object.key("MinimumHealthyPercent").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.minimum_healthy_percent).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_service_deployment_controller_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsServiceDeploymentControllerDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2845) = &input.r#type {
object.key("Type").string(var_2845.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_service_load_balancers_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsServiceLoadBalancersDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2846) = &input.container_name {
object.key("ContainerName").string(var_2846.as_str());
}
if input.container_port != 0 {
object.key("ContainerPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.container_port).into()),
);
}
if let Some(var_2847) = &input.load_balancer_name {
object.key("LoadBalancerName").string(var_2847.as_str());
}
if let Some(var_2848) = &input.target_group_arn {
object.key("TargetGroupArn").string(var_2848.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_service_network_configuration_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsServiceNetworkConfigurationDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2849) = &input.aws_vpc_configuration {
#[allow(unused_mut)]
let mut object_2850 = object.key("AwsVpcConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_service_network_configuration_aws_vpc_configuration_details(&mut object_2850, var_2849)?;
object_2850.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_service_placement_constraints_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsServicePlacementConstraintsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2851) = &input.expression {
object.key("Expression").string(var_2851.as_str());
}
if let Some(var_2852) = &input.r#type {
object.key("Type").string(var_2852.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_service_placement_strategies_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsServicePlacementStrategiesDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2853) = &input.field {
object.key("Field").string(var_2853.as_str());
}
if let Some(var_2854) = &input.r#type {
object.key("Type").string(var_2854.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_service_service_registries_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsServiceServiceRegistriesDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2855) = &input.container_name {
object.key("ContainerName").string(var_2855.as_str());
}
if input.container_port != 0 {
object.key("ContainerPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.container_port).into()),
);
}
if input.port != 0 {
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port).into()),
);
}
if let Some(var_2856) = &input.registry_arn {
object.key("RegistryArn").string(var_2856.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_auto_scaling_launch_configuration_block_device_mappings_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsAutoScalingLaunchConfigurationBlockDeviceMappingsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2857) = &input.device_name {
object.key("DeviceName").string(var_2857.as_str());
}
if let Some(var_2858) = &input.ebs {
#[allow(unused_mut)]
let mut object_2859 = object.key("Ebs").start_object();
crate::json_ser::serialize_structure_crate_model_aws_auto_scaling_launch_configuration_block_device_mappings_ebs_details(&mut object_2859, var_2858)?;
object_2859.finish();
}
if input.no_device {
object.key("NoDevice").boolean(input.no_device);
}
if let Some(var_2860) = &input.virtual_name {
object.key("VirtualName").string(var_2860.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_auto_scaling_launch_configuration_instance_monitoring_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsAutoScalingLaunchConfigurationInstanceMonitoringDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_auto_scaling_launch_configuration_metadata_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsAutoScalingLaunchConfigurationMetadataOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2861) = &input.http_endpoint {
object.key("HttpEndpoint").string(var_2861.as_str());
}
if input.http_put_response_hop_limit != 0 {
object.key("HttpPutResponseHopLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.http_put_response_hop_limit).into()),
);
}
if let Some(var_2862) = &input.http_tokens {
object.key("HttpTokens").string(var_2862.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_vpn_connection_vgw_telemetry_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2VpnConnectionVgwTelemetryDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.accepted_route_count != 0 {
object.key("AcceptedRouteCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.accepted_route_count).into()),
);
}
if let Some(var_2863) = &input.certificate_arn {
object.key("CertificateArn").string(var_2863.as_str());
}
if let Some(var_2864) = &input.last_status_change {
object.key("LastStatusChange").string(var_2864.as_str());
}
if let Some(var_2865) = &input.outside_ip_address {
object.key("OutsideIpAddress").string(var_2865.as_str());
}
if let Some(var_2866) = &input.status {
object.key("Status").string(var_2866.as_str());
}
if let Some(var_2867) = &input.status_message {
object.key("StatusMessage").string(var_2867.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_vpn_connection_options_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2VpnConnectionOptionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.static_routes_only {
object
.key("StaticRoutesOnly")
.boolean(input.static_routes_only);
}
if let Some(var_2868) = &input.tunnel_options {
let mut array_2869 = object.key("TunnelOptions").start_array();
for item_2870 in var_2868 {
{
#[allow(unused_mut)]
let mut object_2871 = array_2869.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_vpn_connection_options_tunnel_options_details(&mut object_2871, item_2870)?;
object_2871.finish();
}
}
array_2869.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_vpn_connection_routes_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2VpnConnectionRoutesDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2872) = &input.destination_cidr_block {
object.key("DestinationCidrBlock").string(var_2872.as_str());
}
if let Some(var_2873) = &input.state {
object.key("State").string(var_2873.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_open_search_service_domain_encryption_at_rest_options_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsOpenSearchServiceDomainEncryptionAtRestOptionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_2874) = &input.kms_key_id {
object.key("KmsKeyId").string(var_2874.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_open_search_service_domain_node_to_node_encryption_options_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsOpenSearchServiceDomainNodeToNodeEncryptionOptionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_open_search_service_domain_service_software_options_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsOpenSearchServiceDomainServiceSoftwareOptionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2875) = &input.automated_update_date {
object.key("AutomatedUpdateDate").string(var_2875.as_str());
}
if input.cancellable {
object.key("Cancellable").boolean(input.cancellable);
}
if let Some(var_2876) = &input.current_version {
object.key("CurrentVersion").string(var_2876.as_str());
}
if let Some(var_2877) = &input.description {
object.key("Description").string(var_2877.as_str());
}
if let Some(var_2878) = &input.new_version {
object.key("NewVersion").string(var_2878.as_str());
}
if input.update_available {
object
.key("UpdateAvailable")
.boolean(input.update_available);
}
if let Some(var_2879) = &input.update_status {
object.key("UpdateStatus").string(var_2879.as_str());
}
if input.optional_deployment {
object
.key("OptionalDeployment")
.boolean(input.optional_deployment);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_open_search_service_domain_cluster_config_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsOpenSearchServiceDomainClusterConfigDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.instance_count != 0 {
object.key("InstanceCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.instance_count).into()),
);
}
if input.warm_enabled {
object.key("WarmEnabled").boolean(input.warm_enabled);
}
if input.warm_count != 0 {
object.key("WarmCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.warm_count).into()),
);
}
if input.dedicated_master_enabled {
object
.key("DedicatedMasterEnabled")
.boolean(input.dedicated_master_enabled);
}
if let Some(var_2880) = &input.zone_awareness_config {
#[allow(unused_mut)]
let mut object_2881 = object.key("ZoneAwarenessConfig").start_object();
crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_cluster_config_zone_awareness_config_details(&mut object_2881, var_2880)?;
object_2881.finish();
}
if input.dedicated_master_count != 0 {
object.key("DedicatedMasterCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.dedicated_master_count).into()),
);
}
if let Some(var_2882) = &input.instance_type {
object.key("InstanceType").string(var_2882.as_str());
}
if let Some(var_2883) = &input.warm_type {
object.key("WarmType").string(var_2883.as_str());
}
if input.zone_awareness_enabled {
object
.key("ZoneAwarenessEnabled")
.boolean(input.zone_awareness_enabled);
}
if let Some(var_2884) = &input.dedicated_master_type {
object.key("DedicatedMasterType").string(var_2884.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_open_search_service_domain_domain_endpoint_options_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsOpenSearchServiceDomainDomainEndpointOptionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2885) = &input.custom_endpoint_certificate_arn {
object
.key("CustomEndpointCertificateArn")
.string(var_2885.as_str());
}
if input.custom_endpoint_enabled {
object
.key("CustomEndpointEnabled")
.boolean(input.custom_endpoint_enabled);
}
if input.enforce_https {
object.key("EnforceHTTPS").boolean(input.enforce_https);
}
if let Some(var_2886) = &input.custom_endpoint {
object.key("CustomEndpoint").string(var_2886.as_str());
}
if let Some(var_2887) = &input.tls_security_policy {
object.key("TLSSecurityPolicy").string(var_2887.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_open_search_service_domain_vpc_options_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsOpenSearchServiceDomainVpcOptionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2888) = &input.security_group_ids {
let mut array_2889 = object.key("SecurityGroupIds").start_array();
for item_2890 in var_2888 {
{
array_2889.value().string(item_2890.as_str());
}
}
array_2889.finish();
}
if let Some(var_2891) = &input.subnet_ids {
let mut array_2892 = object.key("SubnetIds").start_array();
for item_2893 in var_2891 {
{
array_2892.value().string(item_2893.as_str());
}
}
array_2892.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_open_search_service_domain_log_publishing_options_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsOpenSearchServiceDomainLogPublishingOptionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2894) = &input.index_slow_logs {
#[allow(unused_mut)]
let mut object_2895 = object.key("IndexSlowLogs").start_object();
crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_log_publishing_option(&mut object_2895, var_2894)?;
object_2895.finish();
}
if let Some(var_2896) = &input.search_slow_logs {
#[allow(unused_mut)]
let mut object_2897 = object.key("SearchSlowLogs").start_object();
crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_log_publishing_option(&mut object_2897, var_2896)?;
object_2897.finish();
}
if let Some(var_2898) = &input.audit_logs {
#[allow(unused_mut)]
let mut object_2899 = object.key("AuditLogs").start_object();
crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_log_publishing_option(&mut object_2899, var_2898)?;
object_2899.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_open_search_service_domain_advanced_security_options_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsOpenSearchServiceDomainAdvancedSecurityOptionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if input.internal_user_database_enabled {
object
.key("InternalUserDatabaseEnabled")
.boolean(input.internal_user_database_enabled);
}
if let Some(var_2900) = &input.master_user_options {
#[allow(unused_mut)]
let mut object_2901 = object.key("MasterUserOptions").start_object();
crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_master_user_options_details(&mut object_2901, var_2900)?;
object_2901.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_vpc_endpoint_service_service_type_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2VpcEndpointServiceServiceTypeDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2902) = &input.service_type {
object.key("ServiceType").string(var_2902.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_waf_rate_based_rule_match_predicate(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafRateBasedRuleMatchPredicate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2903) = &input.data_id {
object.key("DataId").string(var_2903.as_str());
}
if input.negated {
object.key("Negated").boolean(input.negated);
}
if let Some(var_2904) = &input.r#type {
object.key("Type").string(var_2904.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_waf_regional_rate_based_rule_match_predicate(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafRegionalRateBasedRuleMatchPredicate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2905) = &input.data_id {
object.key("DataId").string(var_2905.as_str());
}
if input.negated {
object.key("Negated").boolean(input.negated);
}
if let Some(var_2906) = &input.r#type {
object.key("Type").string(var_2906.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecr_repository_image_scanning_configuration_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcrRepositoryImageScanningConfigurationDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.scan_on_push {
object.key("ScanOnPush").boolean(input.scan_on_push);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecr_repository_lifecycle_policy_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcrRepositoryLifecyclePolicyDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2907) = &input.lifecycle_policy_text {
object.key("LifecyclePolicyText").string(var_2907.as_str());
}
if let Some(var_2908) = &input.registry_id {
object.key("RegistryId").string(var_2908.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_eks_cluster_resources_vpc_config_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEksClusterResourcesVpcConfigDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2909) = &input.security_group_ids {
let mut array_2910 = object.key("SecurityGroupIds").start_array();
for item_2911 in var_2909 {
{
array_2910.value().string(item_2911.as_str());
}
}
array_2910.finish();
}
if let Some(var_2912) = &input.subnet_ids {
let mut array_2913 = object.key("SubnetIds").start_array();
for item_2914 in var_2912 {
{
array_2913.value().string(item_2914.as_str());
}
}
array_2913.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_eks_cluster_logging_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEksClusterLoggingDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2915) = &input.cluster_logging {
let mut array_2916 = object.key("ClusterLogging").start_array();
for item_2917 in var_2915 {
{
#[allow(unused_mut)]
let mut object_2918 = array_2916.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_eks_cluster_logging_cluster_logging_details(&mut object_2918, item_2917)?;
object_2918.finish();
}
}
array_2916.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_firewall_policy_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FirewallPolicyDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2919) = &input.stateful_rule_group_references {
let mut array_2920 = object.key("StatefulRuleGroupReferences").start_array();
for item_2921 in var_2919 {
{
#[allow(unused_mut)]
let mut object_2922 = array_2920.value().start_object();
crate::json_ser::serialize_structure_crate_model_firewall_policy_stateful_rule_group_references_details(&mut object_2922, item_2921)?;
object_2922.finish();
}
}
array_2920.finish();
}
if let Some(var_2923) = &input.stateless_custom_actions {
let mut array_2924 = object.key("StatelessCustomActions").start_array();
for item_2925 in var_2923 {
{
#[allow(unused_mut)]
let mut object_2926 = array_2924.value().start_object();
crate::json_ser::serialize_structure_crate_model_firewall_policy_stateless_custom_actions_details(&mut object_2926, item_2925)?;
object_2926.finish();
}
}
array_2924.finish();
}
if let Some(var_2927) = &input.stateless_default_actions {
let mut array_2928 = object.key("StatelessDefaultActions").start_array();
for item_2929 in var_2927 {
{
array_2928.value().string(item_2929.as_str());
}
}
array_2928.finish();
}
if let Some(var_2930) = &input.stateless_fragment_default_actions {
let mut array_2931 = object.key("StatelessFragmentDefaultActions").start_array();
for item_2932 in var_2930 {
{
array_2931.value().string(item_2932.as_str());
}
}
array_2931.finish();
}
if let Some(var_2933) = &input.stateless_rule_group_references {
let mut array_2934 = object.key("StatelessRuleGroupReferences").start_array();
for item_2935 in var_2933 {
{
#[allow(unused_mut)]
let mut object_2936 = array_2934.value().start_object();
crate::json_ser::serialize_structure_crate_model_firewall_policy_stateless_rule_group_references_details(&mut object_2936, item_2935)?;
object_2936.finish();
}
}
array_2934.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_network_firewall_firewall_subnet_mappings_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsNetworkFirewallFirewallSubnetMappingsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2937) = &input.subnet_id {
object.key("SubnetId").string(var_2937.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_group_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleGroupDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2938) = &input.rule_variables {
#[allow(unused_mut)]
let mut object_2939 = object.key("RuleVariables").start_object();
crate::json_ser::serialize_structure_crate_model_rule_group_variables(
&mut object_2939,
var_2938,
)?;
object_2939.finish();
}
if let Some(var_2940) = &input.rules_source {
#[allow(unused_mut)]
let mut object_2941 = object.key("RulesSource").start_object();
crate::json_ser::serialize_structure_crate_model_rule_group_source(
&mut object_2941,
var_2940,
)?;
object_2941.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_rds_db_security_group_ec2_security_group(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRdsDbSecurityGroupEc2SecurityGroup,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2942) = &input.ec2_security_group_id {
object.key("Ec2SecurityGroupId").string(var_2942.as_str());
}
if let Some(var_2943) = &input.ec2_security_group_name {
object.key("Ec2SecurityGroupName").string(var_2943.as_str());
}
if let Some(var_2944) = &input.ec2_security_group_owner_id {
object
.key("Ec2SecurityGroupOwnerId")
.string(var_2944.as_str());
}
if let Some(var_2945) = &input.status {
object.key("Status").string(var_2945.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_rds_db_security_group_ip_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRdsDbSecurityGroupIpRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2946) = &input.cidr_ip {
object.key("CidrIp").string(var_2946.as_str());
}
if let Some(var_2947) = &input.status {
object.key("Status").string(var_2947.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_kinesis_stream_stream_encryption_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsKinesisStreamStreamEncryptionDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2948) = &input.encryption_type {
object.key("EncryptionType").string(var_2948.as_str());
}
if let Some(var_2949) = &input.key_id {
object.key("KeyId").string(var_2949.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_efs_access_point_posix_user_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEfsAccessPointPosixUserDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2950) = &input.gid {
object.key("Gid").string(var_2950.as_str());
}
if let Some(var_2951) = &input.secondary_gids {
let mut array_2952 = object.key("SecondaryGids").start_array();
for item_2953 in var_2951 {
{
array_2952.value().string(item_2953.as_str());
}
}
array_2952.finish();
}
if let Some(var_2954) = &input.uid {
object.key("Uid").string(var_2954.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_efs_access_point_root_directory_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEfsAccessPointRootDirectoryDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2955) = &input.creation_info {
#[allow(unused_mut)]
let mut object_2956 = object.key("CreationInfo").start_object();
crate::json_ser::serialize_structure_crate_model_aws_efs_access_point_root_directory_creation_info_details(&mut object_2956, var_2955)?;
object_2956.finish();
}
if let Some(var_2957) = &input.path {
object.key("Path").string(var_2957.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_cloud_formation_stack_drift_information_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCloudFormationStackDriftInformationDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2958) = &input.stack_drift_status {
object.key("StackDriftStatus").string(var_2958.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_cloud_formation_stack_outputs_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCloudFormationStackOutputsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2959) = &input.description {
object.key("Description").string(var_2959.as_str());
}
if let Some(var_2960) = &input.output_key {
object.key("OutputKey").string(var_2960.as_str());
}
if let Some(var_2961) = &input.output_value {
object.key("OutputValue").string(var_2961.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_cloud_watch_alarm_dimensions_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCloudWatchAlarmDimensionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2962) = &input.name {
object.key("Name").string(var_2962.as_str());
}
if let Some(var_2963) = &input.value {
object.key("Value").string(var_2963.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_vpc_peering_connection_vpc_info_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2VpcPeeringConnectionVpcInfoDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2964) = &input.cidr_block {
object.key("CidrBlock").string(var_2964.as_str());
}
if let Some(var_2965) = &input.cidr_block_set {
let mut array_2966 = object.key("CidrBlockSet").start_array();
for item_2967 in var_2965 {
{
#[allow(unused_mut)]
let mut object_2968 = array_2966.value().start_object();
crate::json_ser::serialize_structure_crate_model_vpc_info_cidr_block_set_details(
&mut object_2968,
item_2967,
)?;
object_2968.finish();
}
}
array_2966.finish();
}
if let Some(var_2969) = &input.ipv6_cidr_block_set {
let mut array_2970 = object.key("Ipv6CidrBlockSet").start_array();
for item_2971 in var_2969 {
{
#[allow(unused_mut)]
let mut object_2972 = array_2970.value().start_object();
crate::json_ser::serialize_structure_crate_model_vpc_info_ipv6_cidr_block_set_details(&mut object_2972, item_2971)?;
object_2972.finish();
}
}
array_2970.finish();
}
if let Some(var_2973) = &input.owner_id {
object.key("OwnerId").string(var_2973.as_str());
}
if let Some(var_2974) = &input.peering_options {
#[allow(unused_mut)]
let mut object_2975 = object.key("PeeringOptions").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_info_peering_options_details(
&mut object_2975,
var_2974,
)?;
object_2975.finish();
}
if let Some(var_2976) = &input.region {
object.key("Region").string(var_2976.as_str());
}
if let Some(var_2977) = &input.vpc_id {
object.key("VpcId").string(var_2977.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_vpc_peering_connection_status_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2VpcPeeringConnectionStatusDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2978) = &input.code {
object.key("Code").string(var_2978.as_str());
}
if let Some(var_2979) = &input.message {
object.key("Message").string(var_2979.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_waf_regional_rule_group_rules_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafRegionalRuleGroupRulesDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2980) = &input.action {
#[allow(unused_mut)]
let mut object_2981 = object.key("Action").start_object();
crate::json_ser::serialize_structure_crate_model_aws_waf_regional_rule_group_rules_action_details(&mut object_2981, var_2980)?;
object_2981.finish();
}
if input.priority != 0 {
object.key("Priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.priority).into()),
);
}
if let Some(var_2982) = &input.rule_id {
object.key("RuleId").string(var_2982.as_str());
}
if let Some(var_2983) = &input.r#type {
object.key("Type").string(var_2983.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_waf_regional_rule_predicate_list_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafRegionalRulePredicateListDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2984) = &input.data_id {
object.key("DataId").string(var_2984.as_str());
}
if input.negated {
object.key("Negated").boolean(input.negated);
}
if let Some(var_2985) = &input.r#type {
object.key("Type").string(var_2985.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_waf_regional_web_acl_rules_list_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafRegionalWebAclRulesListDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2986) = &input.action {
#[allow(unused_mut)]
let mut object_2987 = object.key("Action").start_object();
crate::json_ser::serialize_structure_crate_model_aws_waf_regional_web_acl_rules_list_action_details(&mut object_2987, var_2986)?;
object_2987.finish();
}
if let Some(var_2988) = &input.override_action {
#[allow(unused_mut)]
let mut object_2989 = object.key("OverrideAction").start_object();
crate::json_ser::serialize_structure_crate_model_aws_waf_regional_web_acl_rules_list_override_action_details(&mut object_2989, var_2988)?;
object_2989.finish();
}
if input.priority != 0 {
object.key("Priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.priority).into()),
);
}
if let Some(var_2990) = &input.rule_id {
object.key("RuleId").string(var_2990.as_str());
}
if let Some(var_2991) = &input.r#type {
object.key("Type").string(var_2991.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_waf_rule_predicate_list_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafRulePredicateListDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2992) = &input.data_id {
object.key("DataId").string(var_2992.as_str());
}
if input.negated {
object.key("Negated").boolean(input.negated);
}
if let Some(var_2993) = &input.r#type {
object.key("Type").string(var_2993.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_waf_rule_group_rules_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafRuleGroupRulesDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2994) = &input.action {
#[allow(unused_mut)]
let mut object_2995 = object.key("Action").start_object();
crate::json_ser::serialize_structure_crate_model_aws_waf_rule_group_rules_action_details(
&mut object_2995,
var_2994,
)?;
object_2995.finish();
}
if input.priority != 0 {
object.key("Priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.priority).into()),
);
}
if let Some(var_2996) = &input.rule_id {
object.key("RuleId").string(var_2996.as_str());
}
if let Some(var_2997) = &input.r#type {
object.key("Type").string(var_2997.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_volume_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskVolumeDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2998) = &input.name {
object.key("Name").string(var_2998.as_str());
}
if let Some(var_2999) = &input.host {
#[allow(unused_mut)]
let mut object_3000 = object.key("Host").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_volume_host_details(
&mut object_3000,
var_2999,
)?;
object_3000.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_backup_backup_vault_notifications_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsBackupBackupVaultNotificationsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3001) = &input.backup_vault_events {
let mut array_3002 = object.key("BackupVaultEvents").start_array();
for item_3003 in var_3001 {
{
array_3002.value().string(item_3003.as_str());
}
}
array_3002.finish();
}
if let Some(var_3004) = &input.sns_topic_arn {
object.key("SnsTopicArn").string(var_3004.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_backup_backup_plan_backup_plan_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsBackupBackupPlanBackupPlanDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3005) = &input.backup_plan_name {
object.key("BackupPlanName").string(var_3005.as_str());
}
if let Some(var_3006) = &input.advanced_backup_settings {
let mut array_3007 = object.key("AdvancedBackupSettings").start_array();
for item_3008 in var_3006 {
{
#[allow(unused_mut)]
let mut object_3009 = array_3007.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_backup_backup_plan_advanced_backup_settings_details(&mut object_3009, item_3008)?;
object_3009.finish();
}
}
array_3007.finish();
}
if let Some(var_3010) = &input.backup_plan_rule {
let mut array_3011 = object.key("BackupPlanRule").start_array();
for item_3012 in var_3010 {
{
#[allow(unused_mut)]
let mut object_3013 = array_3011.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_backup_backup_plan_rule_details(&mut object_3013, item_3012)?;
object_3013.finish();
}
}
array_3011.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_backup_recovery_point_calculated_lifecycle_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsBackupRecoveryPointCalculatedLifecycleDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3014) = &input.delete_at {
object.key("DeleteAt").string(var_3014.as_str());
}
if let Some(var_3015) = &input.move_to_cold_storage_at {
object.key("MoveToColdStorageAt").string(var_3015.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_backup_recovery_point_created_by_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsBackupRecoveryPointCreatedByDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3016) = &input.backup_plan_arn {
object.key("BackupPlanArn").string(var_3016.as_str());
}
if let Some(var_3017) = &input.backup_plan_id {
object.key("BackupPlanId").string(var_3017.as_str());
}
if let Some(var_3018) = &input.backup_plan_version {
object.key("BackupPlanVersion").string(var_3018.as_str());
}
if let Some(var_3019) = &input.backup_rule_id {
object.key("BackupRuleId").string(var_3019.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_backup_recovery_point_lifecycle_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsBackupRecoveryPointLifecycleDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.delete_after_days != 0 {
object.key("DeleteAfterDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.delete_after_days).into()),
);
}
if input.move_to_cold_storage_after_days != 0 {
object.key("MoveToColdStorageAfterDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.move_to_cold_storage_after_days).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3020) = &input.block_device_mapping_set {
let mut array_3021 = object.key("BlockDeviceMappingSet").start_array();
for item_3022 in var_3020 {
{
#[allow(unused_mut)]
let mut object_3023 = array_3021.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_block_device_mapping_set_details(&mut object_3023, item_3022)?;
object_3023.finish();
}
}
array_3021.finish();
}
if let Some(var_3024) = &input.capacity_reservation_specification {
#[allow(unused_mut)]
let mut object_3025 = object
.key("CapacityReservationSpecification")
.start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_capacity_reservation_specification_details(&mut object_3025, var_3024)?;
object_3025.finish();
}
if let Some(var_3026) = &input.cpu_options {
#[allow(unused_mut)]
let mut object_3027 = object.key("CpuOptions").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_cpu_options_details(&mut object_3027, var_3026)?;
object_3027.finish();
}
if let Some(var_3028) = &input.credit_specification {
#[allow(unused_mut)]
let mut object_3029 = object.key("CreditSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_credit_specification_details(&mut object_3029, var_3028)?;
object_3029.finish();
}
if input.disable_api_stop {
object.key("DisableApiStop").boolean(input.disable_api_stop);
}
if input.disable_api_termination {
object
.key("DisableApiTermination")
.boolean(input.disable_api_termination);
}
if input.ebs_optimized {
object.key("EbsOptimized").boolean(input.ebs_optimized);
}
if let Some(var_3030) = &input.elastic_gpu_specification_set {
let mut array_3031 = object.key("ElasticGpuSpecificationSet").start_array();
for item_3032 in var_3030 {
{
#[allow(unused_mut)]
let mut object_3033 = array_3031.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_elastic_gpu_specification_set_details(&mut object_3033, item_3032)?;
object_3033.finish();
}
}
array_3031.finish();
}
if let Some(var_3034) = &input.elastic_inference_accelerator_set {
let mut array_3035 = object.key("ElasticInferenceAcceleratorSet").start_array();
for item_3036 in var_3034 {
{
#[allow(unused_mut)]
let mut object_3037 = array_3035.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_elastic_inference_accelerator_set_details(&mut object_3037, item_3036)?;
object_3037.finish();
}
}
array_3035.finish();
}
if let Some(var_3038) = &input.enclave_options {
#[allow(unused_mut)]
let mut object_3039 = object.key("EnclaveOptions").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_enclave_options_details(&mut object_3039, var_3038)?;
object_3039.finish();
}
if let Some(var_3040) = &input.hibernation_options {
#[allow(unused_mut)]
let mut object_3041 = object.key("HibernationOptions").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_hibernation_options_details(&mut object_3041, var_3040)?;
object_3041.finish();
}
if let Some(var_3042) = &input.iam_instance_profile {
#[allow(unused_mut)]
let mut object_3043 = object.key("IamInstanceProfile").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_iam_instance_profile_details(&mut object_3043, var_3042)?;
object_3043.finish();
}
if let Some(var_3044) = &input.image_id {
object.key("ImageId").string(var_3044.as_str());
}
if let Some(var_3045) = &input.instance_initiated_shutdown_behavior {
object
.key("InstanceInitiatedShutdownBehavior")
.string(var_3045.as_str());
}
if let Some(var_3046) = &input.instance_market_options {
#[allow(unused_mut)]
let mut object_3047 = object.key("InstanceMarketOptions").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_instance_market_options_details(&mut object_3047, var_3046)?;
object_3047.finish();
}
if let Some(var_3048) = &input.instance_requirements {
#[allow(unused_mut)]
let mut object_3049 = object.key("InstanceRequirements").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_instance_requirements_details(&mut object_3049, var_3048)?;
object_3049.finish();
}
if let Some(var_3050) = &input.instance_type {
object.key("InstanceType").string(var_3050.as_str());
}
if let Some(var_3051) = &input.kernel_id {
object.key("KernelId").string(var_3051.as_str());
}
if let Some(var_3052) = &input.key_name {
object.key("KeyName").string(var_3052.as_str());
}
if let Some(var_3053) = &input.license_set {
let mut array_3054 = object.key("LicenseSet").start_array();
for item_3055 in var_3053 {
{
#[allow(unused_mut)]
let mut object_3056 = array_3054.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_license_set_details(&mut object_3056, item_3055)?;
object_3056.finish();
}
}
array_3054.finish();
}
if let Some(var_3057) = &input.maintenance_options {
#[allow(unused_mut)]
let mut object_3058 = object.key("MaintenanceOptions").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_maintenance_options_details(&mut object_3058, var_3057)?;
object_3058.finish();
}
if let Some(var_3059) = &input.metadata_options {
#[allow(unused_mut)]
let mut object_3060 = object.key("MetadataOptions").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_metadata_options_details(&mut object_3060, var_3059)?;
object_3060.finish();
}
if let Some(var_3061) = &input.monitoring {
#[allow(unused_mut)]
let mut object_3062 = object.key("Monitoring").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_monitoring_details(&mut object_3062, var_3061)?;
object_3062.finish();
}
if let Some(var_3063) = &input.network_interface_set {
let mut array_3064 = object.key("NetworkInterfaceSet").start_array();
for item_3065 in var_3063 {
{
#[allow(unused_mut)]
let mut object_3066 = array_3064.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_network_interface_set_details(&mut object_3066, item_3065)?;
object_3066.finish();
}
}
array_3064.finish();
}
if let Some(var_3067) = &input.placement {
#[allow(unused_mut)]
let mut object_3068 = object.key("Placement").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_placement_details(&mut object_3068, var_3067)?;
object_3068.finish();
}
if let Some(var_3069) = &input.private_dns_name_options {
#[allow(unused_mut)]
let mut object_3070 = object.key("PrivateDnsNameOptions").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_private_dns_name_options_details(&mut object_3070, var_3069)?;
object_3070.finish();
}
if let Some(var_3071) = &input.ram_disk_id {
object.key("RamDiskId").string(var_3071.as_str());
}
if let Some(var_3072) = &input.security_group_id_set {
let mut array_3073 = object.key("SecurityGroupIdSet").start_array();
for item_3074 in var_3072 {
{
array_3073.value().string(item_3074.as_str());
}
}
array_3073.finish();
}
if let Some(var_3075) = &input.security_group_set {
let mut array_3076 = object.key("SecurityGroupSet").start_array();
for item_3077 in var_3075 {
{
array_3076.value().string(item_3077.as_str());
}
}
array_3076.finish();
}
if let Some(var_3078) = &input.user_data {
object.key("UserData").string(var_3078.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_sage_maker_notebook_instance_metadata_service_configuration_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsSageMakerNotebookInstanceMetadataServiceConfigurationDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3079) = &input.minimum_instance_metadata_service_version {
object
.key("MinimumInstanceMetadataServiceVersion")
.string(var_3079.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_wafv2_web_acl_captcha_config_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafv2WebAclCaptchaConfigDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3080) = &input.immunity_time_property {
#[allow(unused_mut)]
let mut object_3081 = object.key("ImmunityTimeProperty").start_object();
crate::json_ser::serialize_structure_crate_model_aws_wafv2_web_acl_captcha_config_immunity_time_property_details(&mut object_3081, var_3080)?;
object_3081.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_wafv2_web_acl_action_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafv2WebAclActionDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3082) = &input.allow {
#[allow(unused_mut)]
let mut object_3083 = object.key("Allow").start_object();
crate::json_ser::serialize_structure_crate_model_aws_wafv2_action_allow_details(
&mut object_3083,
var_3082,
)?;
object_3083.finish();
}
if let Some(var_3084) = &input.block {
#[allow(unused_mut)]
let mut object_3085 = object.key("Block").start_object();
crate::json_ser::serialize_structure_crate_model_aws_wafv2_action_block_details(
&mut object_3085,
var_3084,
)?;
object_3085.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_wafv2_rules_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafv2RulesDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3086) = &input.action {
#[allow(unused_mut)]
let mut object_3087 = object.key("Action").start_object();
crate::json_ser::serialize_structure_crate_model_aws_wafv2_rules_action_details(
&mut object_3087,
var_3086,
)?;
object_3087.finish();
}
if let Some(var_3088) = &input.name {
object.key("Name").string(var_3088.as_str());
}
if let Some(var_3089) = &input.override_action {
object.key("OverrideAction").string(var_3089.as_str());
}
if input.priority != 0 {
object.key("Priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.priority).into()),
);
}
if let Some(var_3090) = &input.visibility_config {
#[allow(unused_mut)]
let mut object_3091 = object.key("VisibilityConfig").start_object();
crate::json_ser::serialize_structure_crate_model_aws_wafv2_visibility_config_details(
&mut object_3091,
var_3090,
)?;
object_3091.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_wafv2_visibility_config_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafv2VisibilityConfigDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.cloud_watch_metrics_enabled {
object
.key("CloudWatchMetricsEnabled")
.boolean(input.cloud_watch_metrics_enabled);
}
if let Some(var_3092) = &input.metric_name {
object.key("MetricName").string(var_3092.as_str());
}
if input.sampled_requests_enabled {
object
.key("SampledRequestsEnabled")
.boolean(input.sampled_requests_enabled);
}
Ok(())
}
pub fn serialize_structure_crate_model_ip_organization_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IpOrganizationDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.asn != 0 {
object.key("Asn").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.asn).into()),
);
}
if let Some(var_3093) = &input.asn_org {
object.key("AsnOrg").string(var_3093.as_str());
}
if let Some(var_3094) = &input.isp {
object.key("Isp").string(var_3094.as_str());
}
if let Some(var_3095) = &input.org {
object.key("Org").string(var_3095.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_country(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Country,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3096) = &input.country_code {
object.key("CountryCode").string(var_3096.as_str());
}
if let Some(var_3097) = &input.country_name {
object.key("CountryName").string(var_3097.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_city(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::City,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3098) = &input.city_name {
object.key("CityName").string(var_3098.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_geo_location(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GeoLocation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.lon != 0.0 {
object.key("Lon").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.lon).into()),
);
}
if input.lat != 0.0 {
object.key("Lat").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.lat).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_action_local_ip_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ActionLocalIpDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3099) = &input.ip_address_v4 {
object.key("IpAddressV4").string(var_3099.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sensitive_data_detections(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SensitiveDataDetections,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.count != 0 {
object.key("Count").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.count).into()),
);
}
if let Some(var_3100) = &input.r#type {
object.key("Type").string(var_3100.as_str());
}
if let Some(var_3101) = &input.occurrences {
#[allow(unused_mut)]
let mut object_3102 = object.key("Occurrences").start_object();
crate::json_ser::serialize_structure_crate_model_occurrences(&mut object_3102, var_3101)?;
object_3102.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_data_identifiers_detections(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomDataIdentifiersDetections,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.count != 0 {
object.key("Count").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.count).into()),
);
}
if let Some(var_3103) = &input.arn {
object.key("Arn").string(var_3103.as_str());
}
if let Some(var_3104) = &input.name {
object.key("Name").string(var_3104.as_str());
}
if let Some(var_3105) = &input.occurrences {
#[allow(unused_mut)]
let mut object_3106 = object.key("Occurrences").start_object();
crate::json_ser::serialize_structure_crate_model_occurrences(&mut object_3106, var_3105)?;
object_3106.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_auto_scaling_auto_scaling_group_mixed_instances_policy_instances_distribution_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsAutoScalingAutoScalingGroupMixedInstancesPolicyInstancesDistributionDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3107) = &input.on_demand_allocation_strategy {
object
.key("OnDemandAllocationStrategy")
.string(var_3107.as_str());
}
if input.on_demand_base_capacity != 0 {
object.key("OnDemandBaseCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.on_demand_base_capacity).into()),
);
}
if input.on_demand_percentage_above_base_capacity != 0 {
object.key("OnDemandPercentageAboveBaseCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt(
(input.on_demand_percentage_above_base_capacity).into(),
),
);
}
if let Some(var_3108) = &input.spot_allocation_strategy {
object
.key("SpotAllocationStrategy")
.string(var_3108.as_str());
}
if input.spot_instance_pools != 0 {
object.key("SpotInstancePools").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.spot_instance_pools).into()),
);
}
if let Some(var_3109) = &input.spot_max_price {
object.key("SpotMaxPrice").string(var_3109.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_auto_scaling_auto_scaling_group_mixed_instances_policy_launch_template_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsAutoScalingAutoScalingGroupMixedInstancesPolicyLaunchTemplateDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3110) = &input.launch_template_specification {
#[allow(unused_mut)]
let mut object_3111 = object.key("LaunchTemplateSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_aws_auto_scaling_auto_scaling_group_mixed_instances_policy_launch_template_launch_template_specification(&mut object_3111, var_3110)?;
object_3111.finish();
}
if let Some(var_3112) = &input.overrides {
let mut array_3113 = object.key("Overrides").start_array();
for item_3114 in var_3112 {
{
#[allow(unused_mut)]
let mut object_3115 = array_3113.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_auto_scaling_auto_scaling_group_mixed_instances_policy_launch_template_overrides_list_details(&mut object_3115, item_3114)?;
object_3115.finish();
}
}
array_3113.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_code_build_project_environment_environment_variables_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCodeBuildProjectEnvironmentEnvironmentVariablesDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3116) = &input.name {
object.key("Name").string(var_3116.as_str());
}
if let Some(var_3117) = &input.r#type {
object.key("Type").string(var_3117.as_str());
}
if let Some(var_3118) = &input.value {
object.key("Value").string(var_3118.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_code_build_project_environment_registry_credential(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCodeBuildProjectEnvironmentRegistryCredential,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3119) = &input.credential {
object.key("Credential").string(var_3119.as_str());
}
if let Some(var_3120) = &input.credential_provider {
object.key("CredentialProvider").string(var_3120.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_code_build_project_logs_config_cloud_watch_logs_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCodeBuildProjectLogsConfigCloudWatchLogsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3121) = &input.group_name {
object.key("GroupName").string(var_3121.as_str());
}
if let Some(var_3122) = &input.status {
object.key("Status").string(var_3122.as_str());
}
if let Some(var_3123) = &input.stream_name {
object.key("StreamName").string(var_3123.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_code_build_project_logs_config_s3_logs_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCodeBuildProjectLogsConfigS3LogsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.encryption_disabled {
object
.key("EncryptionDisabled")
.boolean(input.encryption_disabled);
}
if let Some(var_3124) = &input.location {
object.key("Location").string(var_3124.as_str());
}
if let Some(var_3125) = &input.status {
object.key("Status").string(var_3125.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_cloud_front_distribution_cache_behavior(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCloudFrontDistributionCacheBehavior,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3126) = &input.viewer_protocol_policy {
object.key("ViewerProtocolPolicy").string(var_3126.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_cloud_front_distribution_origin_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCloudFrontDistributionOriginItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3127) = &input.domain_name {
object.key("DomainName").string(var_3127.as_str());
}
if let Some(var_3128) = &input.id {
object.key("Id").string(var_3128.as_str());
}
if let Some(var_3129) = &input.origin_path {
object.key("OriginPath").string(var_3129.as_str());
}
if let Some(var_3130) = &input.s3_origin_config {
#[allow(unused_mut)]
let mut object_3131 = object.key("S3OriginConfig").start_object();
crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_origin_s3_origin_config(&mut object_3131, var_3130)?;
object_3131.finish();
}
if let Some(var_3132) = &input.custom_origin_config {
#[allow(unused_mut)]
let mut object_3133 = object.key("CustomOriginConfig").start_object();
crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_origin_custom_origin_config(&mut object_3133, var_3132)?;
object_3133.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_cloud_front_distribution_origin_group(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCloudFrontDistributionOriginGroup,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3134) = &input.failover_criteria {
#[allow(unused_mut)]
let mut object_3135 = object.key("FailoverCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_origin_group_failover(&mut object_3135, var_3134)?;
object_3135.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_security_group_user_id_group_pair(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2SecurityGroupUserIdGroupPair,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3136) = &input.group_id {
object.key("GroupId").string(var_3136.as_str());
}
if let Some(var_3137) = &input.group_name {
object.key("GroupName").string(var_3137.as_str());
}
if let Some(var_3138) = &input.peering_status {
object.key("PeeringStatus").string(var_3138.as_str());
}
if let Some(var_3139) = &input.user_id {
object.key("UserId").string(var_3139.as_str());
}
if let Some(var_3140) = &input.vpc_id {
object.key("VpcId").string(var_3140.as_str());
}
if let Some(var_3141) = &input.vpc_peering_connection_id {
object
.key("VpcPeeringConnectionId")
.string(var_3141.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_security_group_ip_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2SecurityGroupIpRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3142) = &input.cidr_ip {
object.key("CidrIp").string(var_3142.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_security_group_ipv6_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2SecurityGroupIpv6Range,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3143) = &input.cidr_ipv6 {
object.key("CidrIpv6").string(var_3143.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_security_group_prefix_list_id(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2SecurityGroupPrefixListId,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3144) = &input.prefix_list_id {
object.key("PrefixListId").string(var_3144.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_icmp_type_code(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IcmpTypeCode,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.code != 0 {
object.key("Code").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.code).into()),
);
}
if input.r#type != 0 {
object.key("Type").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.r#type).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_port_range_from_to(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PortRangeFromTo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.from != 0 {
object.key("From").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.from).into()),
);
}
if input.to != 0 {
object.key("To").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.to).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elasticsearch_domain_elasticsearch_cluster_config_zone_awareness_config_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElasticsearchDomainElasticsearchClusterConfigZoneAwarenessConfigDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.availability_zone_count != 0 {
object.key("AvailabilityZoneCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.availability_zone_count).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elasticsearch_domain_log_publishing_options_log_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElasticsearchDomainLogPublishingOptionsLogConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3145) = &input.cloud_watch_logs_log_group_arn {
object
.key("CloudWatchLogsLogGroupArn")
.string(var_3145.as_str());
}
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_server_side_encryption_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketServerSideEncryptionRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3146) = &input.apply_server_side_encryption_by_default {
#[allow(unused_mut)]
let mut object_3147 = object
.key("ApplyServerSideEncryptionByDefault")
.start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_server_side_encryption_by_default(&mut object_3147, var_3146)?;
object_3147.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketBucketLifecycleConfigurationRulesDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3148) = &input.abort_incomplete_multipart_upload {
#[allow(unused_mut)]
let mut object_3149 = object.key("AbortIncompleteMultipartUpload").start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_abort_incomplete_multipart_upload_details(&mut object_3149, var_3148)?;
object_3149.finish();
}
if let Some(var_3150) = &input.expiration_date {
object.key("ExpirationDate").string(var_3150.as_str());
}
if input.expiration_in_days != 0 {
object.key("ExpirationInDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.expiration_in_days).into()),
);
}
if input.expired_object_delete_marker {
object
.key("ExpiredObjectDeleteMarker")
.boolean(input.expired_object_delete_marker);
}
if let Some(var_3151) = &input.filter {
#[allow(unused_mut)]
let mut object_3152 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_filter_details(&mut object_3152, var_3151)?;
object_3152.finish();
}
if let Some(var_3153) = &input.id {
object.key("ID").string(var_3153.as_str());
}
if input.noncurrent_version_expiration_in_days != 0 {
object.key("NoncurrentVersionExpirationInDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.noncurrent_version_expiration_in_days).into()),
);
}
if let Some(var_3154) = &input.noncurrent_version_transitions {
let mut array_3155 = object.key("NoncurrentVersionTransitions").start_array();
for item_3156 in var_3154 {
{
#[allow(unused_mut)]
let mut object_3157 = array_3155.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_noncurrent_version_transitions_details(&mut object_3157, item_3156)?;
object_3157.finish();
}
}
array_3155.finish();
}
if let Some(var_3158) = &input.prefix {
object.key("Prefix").string(var_3158.as_str());
}
if let Some(var_3159) = &input.status {
object.key("Status").string(var_3159.as_str());
}
if let Some(var_3160) = &input.transitions {
let mut array_3161 = object.key("Transitions").start_array();
for item_3162 in var_3160 {
{
#[allow(unused_mut)]
let mut object_3163 = array_3161.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_transitions_details(&mut object_3163, item_3162)?;
object_3163.finish();
}
}
array_3161.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_website_configuration_redirect_to(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketWebsiteConfigurationRedirectTo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3164) = &input.hostname {
object.key("Hostname").string(var_3164.as_str());
}
if let Some(var_3165) = &input.protocol {
object.key("Protocol").string(var_3165.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_website_configuration_routing_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketWebsiteConfigurationRoutingRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3166) = &input.condition {
#[allow(unused_mut)]
let mut object_3167 = object.key("Condition").start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_website_configuration_routing_rule_condition(&mut object_3167, var_3166)?;
object_3167.finish();
}
if let Some(var_3168) = &input.redirect {
#[allow(unused_mut)]
let mut object_3169 = object.key("Redirect").start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_website_configuration_routing_rule_redirect(&mut object_3169, var_3168)?;
object_3169.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_notification_configuration_detail(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketNotificationConfigurationDetail,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3170) = &input.events {
let mut array_3171 = object.key("Events").start_array();
for item_3172 in var_3170 {
{
array_3171.value().string(item_3172.as_str());
}
}
array_3171.finish();
}
if let Some(var_3173) = &input.filter {
#[allow(unused_mut)]
let mut object_3174 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_notification_configuration_filter(&mut object_3174, var_3173)?;
object_3174.finish();
}
if let Some(var_3175) = &input.destination {
object.key("Destination").string(var_3175.as_str());
}
if let Some(var_3176) = &input.r#type {
object.key("Type").string(var_3176.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_iam_access_key_session_context_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsIamAccessKeySessionContextAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.mfa_authenticated {
object
.key("MfaAuthenticated")
.boolean(input.mfa_authenticated);
}
if let Some(var_3177) = &input.creation_date {
object.key("CreationDate").string(var_3177.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_iam_access_key_session_context_session_issuer(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsIamAccessKeySessionContextSessionIssuer,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3178) = &input.r#type {
object.key("Type").string(var_3178.as_str());
}
if let Some(var_3179) = &input.principal_id {
object.key("PrincipalId").string(var_3179.as_str());
}
if let Some(var_3180) = &input.arn {
object.key("Arn").string(var_3180.as_str());
}
if let Some(var_3181) = &input.account_id {
object.key("AccountId").string(var_3181.as_str());
}
if let Some(var_3182) = &input.user_name {
object.key("UserName").string(var_3182.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_dynamo_db_table_projection(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsDynamoDbTableProjection,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3183) = &input.non_key_attributes {
let mut array_3184 = object.key("NonKeyAttributes").start_array();
for item_3185 in var_3183 {
{
array_3184.value().string(item_3185.as_str());
}
}
array_3184.finish();
}
if let Some(var_3186) = &input.projection_type {
object.key("ProjectionType").string(var_3186.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_dynamo_db_table_replica_global_secondary_index(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsDynamoDbTableReplicaGlobalSecondaryIndex,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3187) = &input.index_name {
object.key("IndexName").string(var_3187.as_str());
}
if let Some(var_3188) = &input.provisioned_throughput_override {
#[allow(unused_mut)]
let mut object_3189 = object.key("ProvisionedThroughputOverride").start_object();
crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_provisioned_throughput_override(&mut object_3189, var_3188)?;
object_3189.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_dynamo_db_table_provisioned_throughput_override(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsDynamoDbTableProvisionedThroughputOverride,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.read_capacity_units != 0 {
object.key("ReadCapacityUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.read_capacity_units).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ssm_compliance_summary(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsSsmComplianceSummary,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3190) = &input.status {
object.key("Status").string(var_3190.as_str());
}
if input.compliant_critical_count != 0 {
object.key("CompliantCriticalCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.compliant_critical_count).into()),
);
}
if input.compliant_high_count != 0 {
object.key("CompliantHighCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.compliant_high_count).into()),
);
}
if input.compliant_medium_count != 0 {
object.key("CompliantMediumCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.compliant_medium_count).into()),
);
}
if let Some(var_3191) = &input.execution_type {
object.key("ExecutionType").string(var_3191.as_str());
}
if input.non_compliant_critical_count != 0 {
object.key("NonCompliantCriticalCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.non_compliant_critical_count).into()),
);
}
if input.compliant_informational_count != 0 {
object.key("CompliantInformationalCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.compliant_informational_count).into()),
);
}
if input.non_compliant_informational_count != 0 {
object.key("NonCompliantInformationalCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.non_compliant_informational_count).into()),
);
}
if input.compliant_unspecified_count != 0 {
object.key("CompliantUnspecifiedCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.compliant_unspecified_count).into()),
);
}
if input.non_compliant_low_count != 0 {
object.key("NonCompliantLowCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.non_compliant_low_count).into()),
);
}
if input.non_compliant_high_count != 0 {
object.key("NonCompliantHighCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.non_compliant_high_count).into()),
);
}
if input.compliant_low_count != 0 {
object.key("CompliantLowCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.compliant_low_count).into()),
);
}
if let Some(var_3192) = &input.compliance_type {
object.key("ComplianceType").string(var_3192.as_str());
}
if let Some(var_3193) = &input.patch_baseline_id {
object.key("PatchBaselineId").string(var_3193.as_str());
}
if let Some(var_3194) = &input.overall_severity {
object.key("OverallSeverity").string(var_3194.as_str());
}
if input.non_compliant_medium_count != 0 {
object.key("NonCompliantMediumCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.non_compliant_medium_count).into()),
);
}
if input.non_compliant_unspecified_count != 0 {
object.key("NonCompliantUnspecifiedCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.non_compliant_unspecified_count).into()),
);
}
if let Some(var_3195) = &input.patch_group {
object.key("PatchGroup").string(var_3195.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_certificate_manager_certificate_resource_record(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCertificateManagerCertificateResourceRecord,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3196) = &input.name {
object.key("Name").string(var_3196.as_str());
}
if let Some(var_3197) = &input.r#type {
object.key("Type").string(var_3197.as_str());
}
if let Some(var_3198) = &input.value {
object.key("Value").string(var_3198.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_redshift_cluster_cluster_parameter_status(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRedshiftClusterClusterParameterStatus,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3199) = &input.parameter_name {
object.key("ParameterName").string(var_3199.as_str());
}
if let Some(var_3200) = &input.parameter_apply_status {
object.key("ParameterApplyStatus").string(var_3200.as_str());
}
if let Some(var_3201) = &input.parameter_apply_error_description {
object
.key("ParameterApplyErrorDescription")
.string(var_3201.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elb_load_balancer_listener(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElbLoadBalancerListener,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.instance_port != 0 {
object.key("InstancePort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.instance_port).into()),
);
}
if let Some(var_3202) = &input.instance_protocol {
object.key("InstanceProtocol").string(var_3202.as_str());
}
if input.load_balancer_port != 0 {
object.key("LoadBalancerPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.load_balancer_port).into()),
);
}
if let Some(var_3203) = &input.protocol {
object.key("Protocol").string(var_3203.as_str());
}
if let Some(var_3204) = &input.ssl_certificate_id {
object.key("SslCertificateId").string(var_3204.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elb_load_balancer_access_log(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElbLoadBalancerAccessLog,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.emit_interval != 0 {
object.key("EmitInterval").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.emit_interval).into()),
);
}
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_3205) = &input.s3_bucket_name {
object.key("S3BucketName").string(var_3205.as_str());
}
if let Some(var_3206) = &input.s3_bucket_prefix {
object.key("S3BucketPrefix").string(var_3206.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elb_load_balancer_connection_draining(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElbLoadBalancerConnectionDraining,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if input.timeout != 0 {
object.key("Timeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.timeout).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elb_load_balancer_connection_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElbLoadBalancerConnectionSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.idle_timeout != 0 {
object.key("IdleTimeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.idle_timeout).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elb_load_balancer_cross_zone_load_balancing(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElbLoadBalancerCrossZoneLoadBalancing,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elb_load_balancer_additional_attribute(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElbLoadBalancerAdditionalAttribute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3207) = &input.key {
object.key("Key").string(var_3207.as_str());
}
if let Some(var_3208) = &input.value {
object.key("Value").string(var_3208.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elb_app_cookie_stickiness_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElbAppCookieStickinessPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3209) = &input.cookie_name {
object.key("CookieName").string(var_3209.as_str());
}
if let Some(var_3210) = &input.policy_name {
object.key("PolicyName").string(var_3210.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_elb_lb_cookie_stickiness_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsElbLbCookieStickinessPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.cookie_expiration_period != 0 {
object.key("CookieExpirationPeriod").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.cookie_expiration_period).into()),
);
}
if let Some(var_3211) = &input.policy_name {
object.key("PolicyName").string(var_3211.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_iam_instance_profile_role(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsIamInstanceProfileRole,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3212) = &input.arn {
object.key("Arn").string(var_3212.as_str());
}
if let Some(var_3213) = &input.assume_role_policy_document {
object
.key("AssumeRolePolicyDocument")
.string(var_3213.as_str());
}
if let Some(var_3214) = &input.create_date {
object.key("CreateDate").string(var_3214.as_str());
}
if let Some(var_3215) = &input.path {
object.key("Path").string(var_3215.as_str());
}
if let Some(var_3216) = &input.role_id {
object.key("RoleId").string(var_3216.as_str());
}
if let Some(var_3217) = &input.role_name {
object.key("RoleName").string(var_3217.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_lambda_function_environment_error(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsLambdaFunctionEnvironmentError,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3218) = &input.error_code {
object.key("ErrorCode").string(var_3218.as_str());
}
if let Some(var_3219) = &input.message {
object.key("Message").string(var_3219.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_rds_db_subnet_group_subnet(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRdsDbSubnetGroupSubnet,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3220) = &input.subnet_identifier {
object.key("SubnetIdentifier").string(var_3220.as_str());
}
if let Some(var_3221) = &input.subnet_availability_zone {
#[allow(unused_mut)]
let mut object_3222 = object.key("SubnetAvailabilityZone").start_object();
crate::json_ser::serialize_structure_crate_model_aws_rds_db_subnet_group_subnet_availability_zone(&mut object_3222, var_3221)?;
object_3222.finish();
}
if let Some(var_3223) = &input.subnet_status {
object.key("SubnetStatus").string(var_3223.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_rds_pending_cloud_watch_logs_exports(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRdsPendingCloudWatchLogsExports,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3224) = &input.log_types_to_enable {
let mut array_3225 = object.key("LogTypesToEnable").start_array();
for item_3226 in var_3224 {
{
array_3225.value().string(item_3226.as_str());
}
}
array_3225.finish();
}
if let Some(var_3227) = &input.log_types_to_disable {
let mut array_3228 = object.key("LogTypesToDisable").start_array();
for item_3229 in var_3227 {
{
array_3228.value().string(item_3229.as_str());
}
}
array_3228.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_waf_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WafAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3230) = &input.r#type {
object.key("Type").string(var_3230.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_waf_excluded_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WafExcludedRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3231) = &input.rule_id {
object.key("RuleId").string(var_3231.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_waf_override_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WafOverrideAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3232) = &input.r#type {
object.key("Type").string(var_3232.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_cluster_configuration_execute_command_configuration_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsClusterConfigurationExecuteCommandConfigurationDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3233) = &input.kms_key_id {
object.key("KmsKeyId").string(var_3233.as_str());
}
if let Some(var_3234) = &input.log_configuration {
#[allow(unused_mut)]
let mut object_3235 = object.key("LogConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_cluster_configuration_execute_command_configuration_log_configuration_details(&mut object_3235, var_3234)?;
object_3235.finish();
}
if let Some(var_3236) = &input.logging {
object.key("Logging").string(var_3236.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_depends_on_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsDependsOnDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3237) = &input.condition {
object.key("Condition").string(var_3237.as_str());
}
if let Some(var_3238) = &input.container_name {
object.key("ContainerName").string(var_3238.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_environment_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsEnvironmentDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3239) = &input.name {
object.key("Name").string(var_3239.as_str());
}
if let Some(var_3240) = &input.value {
object.key("Value").string(var_3240.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_environment_files_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsEnvironmentFilesDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3241) = &input.r#type {
object.key("Type").string(var_3241.as_str());
}
if let Some(var_3242) = &input.value {
object.key("Value").string(var_3242.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_extra_hosts_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsExtraHostsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3243) = &input.hostname {
object.key("Hostname").string(var_3243.as_str());
}
if let Some(var_3244) = &input.ip_address {
object.key("IpAddress").string(var_3244.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_firelens_configuration_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsFirelensConfigurationDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3245) = &input.options {
#[allow(unused_mut)]
let mut object_3246 = object.key("Options").start_object();
for (key_3247, value_3248) in var_3245 {
{
object_3246
.key(key_3247.as_str())
.string(value_3248.as_str());
}
}
object_3246.finish();
}
if let Some(var_3249) = &input.r#type {
object.key("Type").string(var_3249.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_health_check_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsHealthCheckDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3250) = &input.command {
let mut array_3251 = object.key("Command").start_array();
for item_3252 in var_3250 {
{
array_3251.value().string(item_3252.as_str());
}
}
array_3251.finish();
}
if input.interval != 0 {
object.key("Interval").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.interval).into()),
);
}
if input.retries != 0 {
object.key("Retries").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.retries).into()),
);
}
if input.start_period != 0 {
object.key("StartPeriod").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.start_period).into()),
);
}
if input.timeout != 0 {
object.key("Timeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.timeout).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_linux_parameters_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsLinuxParametersDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3253) = &input.capabilities {
#[allow(unused_mut)]
let mut object_3254 = object.key("Capabilities").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_linux_parameters_capabilities_details(&mut object_3254, var_3253)?;
object_3254.finish();
}
if let Some(var_3255) = &input.devices {
let mut array_3256 = object.key("Devices").start_array();
for item_3257 in var_3255 {
{
#[allow(unused_mut)]
let mut object_3258 = array_3256.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_linux_parameters_devices_details(&mut object_3258, item_3257)?;
object_3258.finish();
}
}
array_3256.finish();
}
if input.init_process_enabled {
object
.key("InitProcessEnabled")
.boolean(input.init_process_enabled);
}
if input.max_swap != 0 {
object.key("MaxSwap").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_swap).into()),
);
}
if input.shared_memory_size != 0 {
object.key("SharedMemorySize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.shared_memory_size).into()),
);
}
if input.swappiness != 0 {
object.key("Swappiness").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.swappiness).into()),
);
}
if let Some(var_3259) = &input.tmpfs {
let mut array_3260 = object.key("Tmpfs").start_array();
for item_3261 in var_3259 {
{
#[allow(unused_mut)]
let mut object_3262 = array_3260.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_linux_parameters_tmpfs_details(&mut object_3262, item_3261)?;
object_3262.finish();
}
}
array_3260.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_log_configuration_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsLogConfigurationDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3263) = &input.log_driver {
object.key("LogDriver").string(var_3263.as_str());
}
if let Some(var_3264) = &input.options {
#[allow(unused_mut)]
let mut object_3265 = object.key("Options").start_object();
for (key_3266, value_3267) in var_3264 {
{
object_3265
.key(key_3266.as_str())
.string(value_3267.as_str());
}
}
object_3265.finish();
}
if let Some(var_3268) = &input.secret_options {
let mut array_3269 = object.key("SecretOptions").start_array();
for item_3270 in var_3268 {
{
#[allow(unused_mut)]
let mut object_3271 = array_3269.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_log_configuration_secret_options_details(&mut object_3271, item_3270)?;
object_3271.finish();
}
}
array_3269.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_mount_points_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsMountPointsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3272) = &input.container_path {
object.key("ContainerPath").string(var_3272.as_str());
}
if input.read_only {
object.key("ReadOnly").boolean(input.read_only);
}
if let Some(var_3273) = &input.source_volume {
object.key("SourceVolume").string(var_3273.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_port_mappings_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsPortMappingsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.container_port != 0 {
object.key("ContainerPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.container_port).into()),
);
}
if input.host_port != 0 {
object.key("HostPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.host_port).into()),
);
}
if let Some(var_3274) = &input.protocol {
object.key("Protocol").string(var_3274.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_repository_credentials_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsRepositoryCredentialsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3275) = &input.credentials_parameter {
object.key("CredentialsParameter").string(var_3275.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_resource_requirements_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsResourceRequirementsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3276) = &input.r#type {
object.key("Type").string(var_3276.as_str());
}
if let Some(var_3277) = &input.value {
object.key("Value").string(var_3277.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_secrets_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsSecretsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3278) = &input.name {
object.key("Name").string(var_3278.as_str());
}
if let Some(var_3279) = &input.value_from {
object.key("ValueFrom").string(var_3279.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_system_controls_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsSystemControlsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3280) = &input.namespace {
object.key("Namespace").string(var_3280.as_str());
}
if let Some(var_3281) = &input.value {
object.key("Value").string(var_3281.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_ulimits_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsUlimitsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.hard_limit != 0 {
object.key("HardLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.hard_limit).into()),
);
}
if let Some(var_3282) = &input.name {
object.key("Name").string(var_3282.as_str());
}
if input.soft_limit != 0 {
object.key("SoftLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.soft_limit).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_volumes_from_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsVolumesFromDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.read_only {
object.key("ReadOnly").boolean(input.read_only);
}
if let Some(var_3283) = &input.source_container {
object.key("SourceContainer").string(var_3283.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_proxy_configuration_proxy_configuration_properties_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionProxyConfigurationProxyConfigurationPropertiesDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3284) = &input.name {
object.key("Name").string(var_3284.as_str());
}
if let Some(var_3285) = &input.value {
object.key("Value").string(var_3285.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_volumes_docker_volume_configuration_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionVolumesDockerVolumeConfigurationDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.autoprovision {
object.key("Autoprovision").boolean(input.autoprovision);
}
if let Some(var_3286) = &input.driver {
object.key("Driver").string(var_3286.as_str());
}
if let Some(var_3287) = &input.driver_opts {
#[allow(unused_mut)]
let mut object_3288 = object.key("DriverOpts").start_object();
for (key_3289, value_3290) in var_3287 {
{
object_3288
.key(key_3289.as_str())
.string(value_3290.as_str());
}
}
object_3288.finish();
}
if let Some(var_3291) = &input.labels {
#[allow(unused_mut)]
let mut object_3292 = object.key("Labels").start_object();
for (key_3293, value_3294) in var_3291 {
{
object_3292
.key(key_3293.as_str())
.string(value_3294.as_str());
}
}
object_3292.finish();
}
if let Some(var_3295) = &input.scope {
object.key("Scope").string(var_3295.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_volumes_efs_volume_configuration_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionVolumesEfsVolumeConfigurationDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3296) = &input.authorization_config {
#[allow(unused_mut)]
let mut object_3297 = object.key("AuthorizationConfig").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_volumes_efs_volume_configuration_authorization_config_details(&mut object_3297, var_3296)?;
object_3297.finish();
}
if let Some(var_3298) = &input.filesystem_id {
object.key("FilesystemId").string(var_3298.as_str());
}
if let Some(var_3299) = &input.root_directory {
object.key("RootDirectory").string(var_3299.as_str());
}
if let Some(var_3300) = &input.transit_encryption {
object.key("TransitEncryption").string(var_3300.as_str());
}
if input.transit_encryption_port != 0 {
object.key("TransitEncryptionPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.transit_encryption_port).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_volumes_host_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionVolumesHostDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3301) = &input.source_path {
object.key("SourcePath").string(var_3301.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_service_deployment_configuration_deployment_circuit_breaker_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsServiceDeploymentConfigurationDeploymentCircuitBreakerDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enable {
object.key("Enable").boolean(input.enable);
}
if input.rollback {
object.key("Rollback").boolean(input.rollback);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_service_network_configuration_aws_vpc_configuration_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsServiceNetworkConfigurationAwsVpcConfigurationDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3302) = &input.assign_public_ip {
object.key("AssignPublicIp").string(var_3302.as_str());
}
if let Some(var_3303) = &input.security_groups {
let mut array_3304 = object.key("SecurityGroups").start_array();
for item_3305 in var_3303 {
{
array_3304.value().string(item_3305.as_str());
}
}
array_3304.finish();
}
if let Some(var_3306) = &input.subnets {
let mut array_3307 = object.key("Subnets").start_array();
for item_3308 in var_3306 {
{
array_3307.value().string(item_3308.as_str());
}
}
array_3307.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_auto_scaling_launch_configuration_block_device_mappings_ebs_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsAutoScalingLaunchConfigurationBlockDeviceMappingsEbsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.delete_on_termination {
object
.key("DeleteOnTermination")
.boolean(input.delete_on_termination);
}
if input.encrypted {
object.key("Encrypted").boolean(input.encrypted);
}
if input.iops != 0 {
object.key("Iops").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.iops).into()),
);
}
if let Some(var_3309) = &input.snapshot_id {
object.key("SnapshotId").string(var_3309.as_str());
}
if input.volume_size != 0 {
object.key("VolumeSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.volume_size).into()),
);
}
if let Some(var_3310) = &input.volume_type {
object.key("VolumeType").string(var_3310.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_vpn_connection_options_tunnel_options_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2VpnConnectionOptionsTunnelOptionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.dpd_timeout_seconds != 0 {
object.key("DpdTimeoutSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.dpd_timeout_seconds).into()),
);
}
if let Some(var_3311) = &input.ike_versions {
let mut array_3312 = object.key("IkeVersions").start_array();
for item_3313 in var_3311 {
{
array_3312.value().string(item_3313.as_str());
}
}
array_3312.finish();
}
if let Some(var_3314) = &input.outside_ip_address {
object.key("OutsideIpAddress").string(var_3314.as_str());
}
if let Some(var_3315) = &input.phase1_dh_group_numbers {
let mut array_3316 = object.key("Phase1DhGroupNumbers").start_array();
for item_3317 in var_3315 {
{
array_3316.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*item_3317).into()),
);
}
}
array_3316.finish();
}
if let Some(var_3318) = &input.phase1_encryption_algorithms {
let mut array_3319 = object.key("Phase1EncryptionAlgorithms").start_array();
for item_3320 in var_3318 {
{
array_3319.value().string(item_3320.as_str());
}
}
array_3319.finish();
}
if let Some(var_3321) = &input.phase1_integrity_algorithms {
let mut array_3322 = object.key("Phase1IntegrityAlgorithms").start_array();
for item_3323 in var_3321 {
{
array_3322.value().string(item_3323.as_str());
}
}
array_3322.finish();
}
if input.phase1_lifetime_seconds != 0 {
object.key("Phase1LifetimeSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.phase1_lifetime_seconds).into()),
);
}
if let Some(var_3324) = &input.phase2_dh_group_numbers {
let mut array_3325 = object.key("Phase2DhGroupNumbers").start_array();
for item_3326 in var_3324 {
{
array_3325.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*item_3326).into()),
);
}
}
array_3325.finish();
}
if let Some(var_3327) = &input.phase2_encryption_algorithms {
let mut array_3328 = object.key("Phase2EncryptionAlgorithms").start_array();
for item_3329 in var_3327 {
{
array_3328.value().string(item_3329.as_str());
}
}
array_3328.finish();
}
if let Some(var_3330) = &input.phase2_integrity_algorithms {
let mut array_3331 = object.key("Phase2IntegrityAlgorithms").start_array();
for item_3332 in var_3330 {
{
array_3331.value().string(item_3332.as_str());
}
}
array_3331.finish();
}
if input.phase2_lifetime_seconds != 0 {
object.key("Phase2LifetimeSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.phase2_lifetime_seconds).into()),
);
}
if let Some(var_3333) = &input.pre_shared_key {
object.key("PreSharedKey").string(var_3333.as_str());
}
if input.rekey_fuzz_percentage != 0 {
object.key("RekeyFuzzPercentage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.rekey_fuzz_percentage).into()),
);
}
if input.rekey_margin_time_seconds != 0 {
object.key("RekeyMarginTimeSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.rekey_margin_time_seconds).into()),
);
}
if input.replay_window_size != 0 {
object.key("ReplayWindowSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.replay_window_size).into()),
);
}
if let Some(var_3334) = &input.tunnel_inside_cidr {
object.key("TunnelInsideCidr").string(var_3334.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_open_search_service_domain_cluster_config_zone_awareness_config_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsOpenSearchServiceDomainClusterConfigZoneAwarenessConfigDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.availability_zone_count != 0 {
object.key("AvailabilityZoneCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.availability_zone_count).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_open_search_service_domain_log_publishing_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsOpenSearchServiceDomainLogPublishingOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3335) = &input.cloud_watch_logs_log_group_arn {
object
.key("CloudWatchLogsLogGroupArn")
.string(var_3335.as_str());
}
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_open_search_service_domain_master_user_options_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsOpenSearchServiceDomainMasterUserOptionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3336) = &input.master_user_arn {
object.key("MasterUserArn").string(var_3336.as_str());
}
if let Some(var_3337) = &input.master_user_name {
object.key("MasterUserName").string(var_3337.as_str());
}
if let Some(var_3338) = &input.master_user_password {
object.key("MasterUserPassword").string(var_3338.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_eks_cluster_logging_cluster_logging_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEksClusterLoggingClusterLoggingDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_3339) = &input.types {
let mut array_3340 = object.key("Types").start_array();
for item_3341 in var_3339 {
{
array_3340.value().string(item_3341.as_str());
}
}
array_3340.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_firewall_policy_stateful_rule_group_references_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FirewallPolicyStatefulRuleGroupReferencesDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3342) = &input.resource_arn {
object.key("ResourceArn").string(var_3342.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_firewall_policy_stateless_custom_actions_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FirewallPolicyStatelessCustomActionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3343) = &input.action_definition {
#[allow(unused_mut)]
let mut object_3344 = object.key("ActionDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_stateless_custom_action_definition(
&mut object_3344,
var_3343,
)?;
object_3344.finish();
}
if let Some(var_3345) = &input.action_name {
object.key("ActionName").string(var_3345.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_firewall_policy_stateless_rule_group_references_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FirewallPolicyStatelessRuleGroupReferencesDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.priority != 0 {
object.key("Priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.priority).into()),
);
}
if let Some(var_3346) = &input.resource_arn {
object.key("ResourceArn").string(var_3346.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_group_variables(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleGroupVariables,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3347) = &input.ip_sets {
#[allow(unused_mut)]
let mut object_3348 = object.key("IpSets").start_object();
crate::json_ser::serialize_structure_crate_model_rule_group_variables_ip_sets_details(
&mut object_3348,
var_3347,
)?;
object_3348.finish();
}
if let Some(var_3349) = &input.port_sets {
#[allow(unused_mut)]
let mut object_3350 = object.key("PortSets").start_object();
crate::json_ser::serialize_structure_crate_model_rule_group_variables_port_sets_details(
&mut object_3350,
var_3349,
)?;
object_3350.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_group_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleGroupSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3351) = &input.rules_source_list {
#[allow(unused_mut)]
let mut object_3352 = object.key("RulesSourceList").start_object();
crate::json_ser::serialize_structure_crate_model_rule_group_source_list_details(
&mut object_3352,
var_3351,
)?;
object_3352.finish();
}
if let Some(var_3353) = &input.rules_string {
object.key("RulesString").string(var_3353.as_str());
}
if let Some(var_3354) = &input.stateful_rules {
let mut array_3355 = object.key("StatefulRules").start_array();
for item_3356 in var_3354 {
{
#[allow(unused_mut)]
let mut object_3357 = array_3355.value().start_object();
crate::json_ser::serialize_structure_crate_model_rule_group_source_stateful_rules_details(&mut object_3357, item_3356)?;
object_3357.finish();
}
}
array_3355.finish();
}
if let Some(var_3358) = &input.stateless_rules_and_custom_actions {
#[allow(unused_mut)]
let mut object_3359 = object.key("StatelessRulesAndCustomActions").start_object();
crate::json_ser::serialize_structure_crate_model_rule_group_source_stateless_rules_and_custom_actions_details(&mut object_3359, var_3358)?;
object_3359.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_efs_access_point_root_directory_creation_info_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEfsAccessPointRootDirectoryCreationInfoDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3360) = &input.owner_gid {
object.key("OwnerGid").string(var_3360.as_str());
}
if let Some(var_3361) = &input.owner_uid {
object.key("OwnerUid").string(var_3361.as_str());
}
if let Some(var_3362) = &input.permissions {
object.key("Permissions").string(var_3362.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_vpc_info_cidr_block_set_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VpcInfoCidrBlockSetDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3363) = &input.cidr_block {
object.key("CidrBlock").string(var_3363.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_vpc_info_ipv6_cidr_block_set_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VpcInfoIpv6CidrBlockSetDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3364) = &input.ipv6_cidr_block {
object.key("Ipv6CidrBlock").string(var_3364.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_vpc_info_peering_options_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VpcInfoPeeringOptionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.allow_dns_resolution_from_remote_vpc {
object
.key("AllowDnsResolutionFromRemoteVpc")
.boolean(input.allow_dns_resolution_from_remote_vpc);
}
if input.allow_egress_from_local_classic_link_to_remote_vpc {
object
.key("AllowEgressFromLocalClassicLinkToRemoteVpc")
.boolean(input.allow_egress_from_local_classic_link_to_remote_vpc);
}
if input.allow_egress_from_local_vpc_to_remote_classic_link {
object
.key("AllowEgressFromLocalVpcToRemoteClassicLink")
.boolean(input.allow_egress_from_local_vpc_to_remote_classic_link);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_waf_regional_rule_group_rules_action_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafRegionalRuleGroupRulesActionDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3365) = &input.r#type {
object.key("Type").string(var_3365.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_waf_regional_web_acl_rules_list_action_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafRegionalWebAclRulesListActionDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3366) = &input.r#type {
object.key("Type").string(var_3366.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_waf_regional_web_acl_rules_list_override_action_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafRegionalWebAclRulesListOverrideActionDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3367) = &input.r#type {
object.key("Type").string(var_3367.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_waf_rule_group_rules_action_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafRuleGroupRulesActionDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3368) = &input.r#type {
object.key("Type").string(var_3368.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_volume_host_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskVolumeHostDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3369) = &input.source_path {
object.key("SourcePath").string(var_3369.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_backup_backup_plan_advanced_backup_settings_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsBackupBackupPlanAdvancedBackupSettingsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3370) = &input.backup_options {
#[allow(unused_mut)]
let mut object_3371 = object.key("BackupOptions").start_object();
for (key_3372, value_3373) in var_3370 {
{
object_3371
.key(key_3372.as_str())
.string(value_3373.as_str());
}
}
object_3371.finish();
}
if let Some(var_3374) = &input.resource_type {
object.key("ResourceType").string(var_3374.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_backup_backup_plan_rule_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsBackupBackupPlanRuleDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3375) = &input.target_backup_vault {
object.key("TargetBackupVault").string(var_3375.as_str());
}
if input.start_window_minutes != 0 {
object.key("StartWindowMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.start_window_minutes).into()),
);
}
if let Some(var_3376) = &input.schedule_expression {
object.key("ScheduleExpression").string(var_3376.as_str());
}
if let Some(var_3377) = &input.rule_name {
object.key("RuleName").string(var_3377.as_str());
}
if let Some(var_3378) = &input.rule_id {
object.key("RuleId").string(var_3378.as_str());
}
if input.enable_continuous_backup {
object
.key("EnableContinuousBackup")
.boolean(input.enable_continuous_backup);
}
if input.completion_window_minutes != 0 {
object.key("CompletionWindowMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.completion_window_minutes).into()),
);
}
if let Some(var_3379) = &input.copy_actions {
let mut array_3380 = object.key("CopyActions").start_array();
for item_3381 in var_3379 {
{
#[allow(unused_mut)]
let mut object_3382 = array_3380.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_backup_backup_plan_rule_copy_actions_details(&mut object_3382, item_3381)?;
object_3382.finish();
}
}
array_3380.finish();
}
if let Some(var_3383) = &input.lifecycle {
#[allow(unused_mut)]
let mut object_3384 = object.key("Lifecycle").start_object();
crate::json_ser::serialize_structure_crate_model_aws_backup_backup_plan_lifecycle_details(
&mut object_3384,
var_3383,
)?;
object_3384.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_block_device_mapping_set_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataBlockDeviceMappingSetDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3385) = &input.device_name {
object.key("DeviceName").string(var_3385.as_str());
}
if let Some(var_3386) = &input.ebs {
#[allow(unused_mut)]
let mut object_3387 = object.key("Ebs").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_block_device_mapping_set_ebs_details(&mut object_3387, var_3386)?;
object_3387.finish();
}
if let Some(var_3388) = &input.no_device {
object.key("NoDevice").string(var_3388.as_str());
}
if let Some(var_3389) = &input.virtual_name {
object.key("VirtualName").string(var_3389.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_capacity_reservation_specification_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataCapacityReservationSpecificationDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3390) = &input.capacity_reservation_preference {
object
.key("CapacityReservationPreference")
.string(var_3390.as_str());
}
if let Some(var_3391) = &input.capacity_reservation_target {
#[allow(unused_mut)]
let mut object_3392 = object.key("CapacityReservationTarget").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_capacity_reservation_specification_capacity_reservation_target_details(&mut object_3392, var_3391)?;
object_3392.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_cpu_options_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataCpuOptionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.core_count != 0 {
object.key("CoreCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.core_count).into()),
);
}
if input.threads_per_core != 0 {
object.key("ThreadsPerCore").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.threads_per_core).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_credit_specification_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataCreditSpecificationDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3393) = &input.cpu_credits {
object.key("CpuCredits").string(var_3393.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_elastic_gpu_specification_set_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataElasticGpuSpecificationSetDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3394) = &input.r#type {
object.key("Type").string(var_3394.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_elastic_inference_accelerator_set_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataElasticInferenceAcceleratorSetDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.count != 0 {
object.key("Count").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.count).into()),
);
}
if let Some(var_3395) = &input.r#type {
object.key("Type").string(var_3395.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_enclave_options_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataEnclaveOptionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_hibernation_options_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataHibernationOptionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.configured {
object.key("Configured").boolean(input.configured);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_iam_instance_profile_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataIamInstanceProfileDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3396) = &input.arn {
object.key("Arn").string(var_3396.as_str());
}
if let Some(var_3397) = &input.name {
object.key("Name").string(var_3397.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_instance_market_options_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataInstanceMarketOptionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3398) = &input.market_type {
object.key("MarketType").string(var_3398.as_str());
}
if let Some(var_3399) = &input.spot_options {
#[allow(unused_mut)]
let mut object_3400 = object.key("SpotOptions").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_instance_market_options_spot_options_details(&mut object_3400, var_3399)?;
object_3400.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_instance_requirements_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataInstanceRequirementsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3401) = &input.accelerator_count {
#[allow(unused_mut)]
let mut object_3402 = object.key("AcceleratorCount").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_instance_requirements_accelerator_count_details(&mut object_3402, var_3401)?;
object_3402.finish();
}
if let Some(var_3403) = &input.accelerator_manufacturers {
let mut array_3404 = object.key("AcceleratorManufacturers").start_array();
for item_3405 in var_3403 {
{
array_3404.value().string(item_3405.as_str());
}
}
array_3404.finish();
}
if let Some(var_3406) = &input.accelerator_names {
let mut array_3407 = object.key("AcceleratorNames").start_array();
for item_3408 in var_3406 {
{
array_3407.value().string(item_3408.as_str());
}
}
array_3407.finish();
}
if let Some(var_3409) = &input.accelerator_total_memory_mi_b {
#[allow(unused_mut)]
let mut object_3410 = object.key("AcceleratorTotalMemoryMiB").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_instance_requirements_accelerator_total_memory_mi_b_details(&mut object_3410, var_3409)?;
object_3410.finish();
}
if let Some(var_3411) = &input.accelerator_types {
let mut array_3412 = object.key("AcceleratorTypes").start_array();
for item_3413 in var_3411 {
{
array_3412.value().string(item_3413.as_str());
}
}
array_3412.finish();
}
if let Some(var_3414) = &input.bare_metal {
object.key("BareMetal").string(var_3414.as_str());
}
if let Some(var_3415) = &input.baseline_ebs_bandwidth_mbps {
#[allow(unused_mut)]
let mut object_3416 = object.key("BaselineEbsBandwidthMbps").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_instance_requirements_baseline_ebs_bandwidth_mbps_details(&mut object_3416, var_3415)?;
object_3416.finish();
}
if let Some(var_3417) = &input.burstable_performance {
object.key("BurstablePerformance").string(var_3417.as_str());
}
if let Some(var_3418) = &input.cpu_manufacturers {
let mut array_3419 = object.key("CpuManufacturers").start_array();
for item_3420 in var_3418 {
{
array_3419.value().string(item_3420.as_str());
}
}
array_3419.finish();
}
if let Some(var_3421) = &input.excluded_instance_types {
let mut array_3422 = object.key("ExcludedInstanceTypes").start_array();
for item_3423 in var_3421 {
{
array_3422.value().string(item_3423.as_str());
}
}
array_3422.finish();
}
if let Some(var_3424) = &input.instance_generations {
let mut array_3425 = object.key("InstanceGenerations").start_array();
for item_3426 in var_3424 {
{
array_3425.value().string(item_3426.as_str());
}
}
array_3425.finish();
}
if let Some(var_3427) = &input.local_storage {
object.key("LocalStorage").string(var_3427.as_str());
}
if let Some(var_3428) = &input.local_storage_types {
let mut array_3429 = object.key("LocalStorageTypes").start_array();
for item_3430 in var_3428 {
{
array_3429.value().string(item_3430.as_str());
}
}
array_3429.finish();
}
if let Some(var_3431) = &input.memory_gi_b_per_v_cpu {
#[allow(unused_mut)]
let mut object_3432 = object.key("MemoryGiBPerVCpu").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_instance_requirements_memory_gi_b_per_v_cpu_details(&mut object_3432, var_3431)?;
object_3432.finish();
}
if let Some(var_3433) = &input.memory_mi_b {
#[allow(unused_mut)]
let mut object_3434 = object.key("MemoryMiB").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_instance_requirements_memory_mi_b_details(&mut object_3434, var_3433)?;
object_3434.finish();
}
if let Some(var_3435) = &input.network_interface_count {
#[allow(unused_mut)]
let mut object_3436 = object.key("NetworkInterfaceCount").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_instance_requirements_network_interface_count_details(&mut object_3436, var_3435)?;
object_3436.finish();
}
if input.on_demand_max_price_percentage_over_lowest_price != 0 {
object
.key("OnDemandMaxPricePercentageOverLowestPrice")
.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt(
(input.on_demand_max_price_percentage_over_lowest_price).into(),
),
);
}
if input.require_hibernate_support {
object
.key("RequireHibernateSupport")
.boolean(input.require_hibernate_support);
}
if input.spot_max_price_percentage_over_lowest_price != 0 {
object.key("SpotMaxPricePercentageOverLowestPrice").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt(
(input.spot_max_price_percentage_over_lowest_price).into(),
),
);
}
if let Some(var_3437) = &input.total_local_storage_gb {
#[allow(unused_mut)]
let mut object_3438 = object.key("TotalLocalStorageGB").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_instance_requirements_total_local_storage_gb_details(&mut object_3438, var_3437)?;
object_3438.finish();
}
if let Some(var_3439) = &input.v_cpu_count {
#[allow(unused_mut)]
let mut object_3440 = object.key("VCpuCount").start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_instance_requirements_v_cpu_count_details(&mut object_3440, var_3439)?;
object_3440.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_license_set_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataLicenseSetDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3441) = &input.license_configuration_arn {
object
.key("LicenseConfigurationArn")
.string(var_3441.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_maintenance_options_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataMaintenanceOptionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3442) = &input.auto_recovery {
object.key("AutoRecovery").string(var_3442.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_metadata_options_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataMetadataOptionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3443) = &input.http_endpoint {
object.key("HttpEndpoint").string(var_3443.as_str());
}
if let Some(var_3444) = &input.http_protocol_ipv6 {
object.key("HttpProtocolIpv6").string(var_3444.as_str());
}
if let Some(var_3445) = &input.http_tokens {
object.key("HttpTokens").string(var_3445.as_str());
}
if input.http_put_response_hop_limit != 0 {
object.key("HttpPutResponseHopLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.http_put_response_hop_limit).into()),
);
}
if let Some(var_3446) = &input.instance_metadata_tags {
object.key("InstanceMetadataTags").string(var_3446.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_monitoring_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataMonitoringDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_network_interface_set_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataNetworkInterfaceSetDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.associate_carrier_ip_address {
object
.key("AssociateCarrierIpAddress")
.boolean(input.associate_carrier_ip_address);
}
if input.associate_public_ip_address {
object
.key("AssociatePublicIpAddress")
.boolean(input.associate_public_ip_address);
}
if input.delete_on_termination {
object
.key("DeleteOnTermination")
.boolean(input.delete_on_termination);
}
if let Some(var_3447) = &input.description {
object.key("Description").string(var_3447.as_str());
}
if input.device_index != 0 {
object.key("DeviceIndex").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.device_index).into()),
);
}
if let Some(var_3448) = &input.groups {
let mut array_3449 = object.key("Groups").start_array();
for item_3450 in var_3448 {
{
array_3449.value().string(item_3450.as_str());
}
}
array_3449.finish();
}
if let Some(var_3451) = &input.interface_type {
object.key("InterfaceType").string(var_3451.as_str());
}
if input.ipv4_prefix_count != 0 {
object.key("Ipv4PrefixCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.ipv4_prefix_count).into()),
);
}
if let Some(var_3452) = &input.ipv4_prefixes {
let mut array_3453 = object.key("Ipv4Prefixes").start_array();
for item_3454 in var_3452 {
{
#[allow(unused_mut)]
let mut object_3455 = array_3453.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_network_interface_set_ipv4_prefixes_details(&mut object_3455, item_3454)?;
object_3455.finish();
}
}
array_3453.finish();
}
if input.ipv6_address_count != 0 {
object.key("Ipv6AddressCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.ipv6_address_count).into()),
);
}
if let Some(var_3456) = &input.ipv6_addresses {
let mut array_3457 = object.key("Ipv6Addresses").start_array();
for item_3458 in var_3456 {
{
#[allow(unused_mut)]
let mut object_3459 = array_3457.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_network_interface_set_ipv6_addresses_details(&mut object_3459, item_3458)?;
object_3459.finish();
}
}
array_3457.finish();
}
if input.ipv6_prefix_count != 0 {
object.key("Ipv6PrefixCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.ipv6_prefix_count).into()),
);
}
if let Some(var_3460) = &input.ipv6_prefixes {
let mut array_3461 = object.key("Ipv6Prefixes").start_array();
for item_3462 in var_3460 {
{
#[allow(unused_mut)]
let mut object_3463 = array_3461.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_network_interface_set_ipv6_prefixes_details(&mut object_3463, item_3462)?;
object_3463.finish();
}
}
array_3461.finish();
}
if input.network_card_index != 0 {
object.key("NetworkCardIndex").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.network_card_index).into()),
);
}
if let Some(var_3464) = &input.network_interface_id {
object.key("NetworkInterfaceId").string(var_3464.as_str());
}
if let Some(var_3465) = &input.private_ip_address {
object.key("PrivateIpAddress").string(var_3465.as_str());
}
if let Some(var_3466) = &input.private_ip_addresses {
let mut array_3467 = object.key("PrivateIpAddresses").start_array();
for item_3468 in var_3466 {
{
#[allow(unused_mut)]
let mut object_3469 = array_3467.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_ec2_launch_template_data_network_interface_set_private_ip_addresses_details(&mut object_3469, item_3468)?;
object_3469.finish();
}
}
array_3467.finish();
}
if input.secondary_private_ip_address_count != 0 {
object.key("SecondaryPrivateIpAddressCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.secondary_private_ip_address_count).into()),
);
}
if let Some(var_3470) = &input.subnet_id {
object.key("SubnetId").string(var_3470.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_placement_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataPlacementDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3471) = &input.affinity {
object.key("Affinity").string(var_3471.as_str());
}
if let Some(var_3472) = &input.availability_zone {
object.key("AvailabilityZone").string(var_3472.as_str());
}
if let Some(var_3473) = &input.group_name {
object.key("GroupName").string(var_3473.as_str());
}
if let Some(var_3474) = &input.host_id {
object.key("HostId").string(var_3474.as_str());
}
if let Some(var_3475) = &input.host_resource_group_arn {
object.key("HostResourceGroupArn").string(var_3475.as_str());
}
if input.partition_number != 0 {
object.key("PartitionNumber").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.partition_number).into()),
);
}
if let Some(var_3476) = &input.spread_domain {
object.key("SpreadDomain").string(var_3476.as_str());
}
if let Some(var_3477) = &input.tenancy {
object.key("Tenancy").string(var_3477.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_private_dns_name_options_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataPrivateDnsNameOptionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enable_resource_name_dns_aaaa_record {
object
.key("EnableResourceNameDnsAAAARecord")
.boolean(input.enable_resource_name_dns_aaaa_record);
}
if input.enable_resource_name_dns_a_record {
object
.key("EnableResourceNameDnsARecord")
.boolean(input.enable_resource_name_dns_a_record);
}
if let Some(var_3478) = &input.hostname_type {
object.key("HostnameType").string(var_3478.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_wafv2_web_acl_captcha_config_immunity_time_property_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafv2WebAclCaptchaConfigImmunityTimePropertyDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.immunity_time != 0 {
object.key("ImmunityTime").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.immunity_time).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_wafv2_action_allow_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafv2ActionAllowDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3479) = &input.custom_request_handling {
#[allow(unused_mut)]
let mut object_3480 = object.key("CustomRequestHandling").start_object();
crate::json_ser::serialize_structure_crate_model_aws_wafv2_custom_request_handling_details(
&mut object_3480,
var_3479,
)?;
object_3480.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_wafv2_action_block_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafv2ActionBlockDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3481) = &input.custom_response {
#[allow(unused_mut)]
let mut object_3482 = object.key("CustomResponse").start_object();
crate::json_ser::serialize_structure_crate_model_aws_wafv2_custom_response_details(
&mut object_3482,
var_3481,
)?;
object_3482.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_wafv2_rules_action_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafv2RulesActionDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3483) = &input.allow {
#[allow(unused_mut)]
let mut object_3484 = object.key("Allow").start_object();
crate::json_ser::serialize_structure_crate_model_aws_wafv2_action_allow_details(
&mut object_3484,
var_3483,
)?;
object_3484.finish();
}
if let Some(var_3485) = &input.block {
#[allow(unused_mut)]
let mut object_3486 = object.key("Block").start_object();
crate::json_ser::serialize_structure_crate_model_aws_wafv2_action_block_details(
&mut object_3486,
var_3485,
)?;
object_3486.finish();
}
if let Some(var_3487) = &input.captcha {
#[allow(unused_mut)]
let mut object_3488 = object.key("Captcha").start_object();
crate::json_ser::serialize_structure_crate_model_aws_wafv2_rules_action_captcha_details(
&mut object_3488,
var_3487,
)?;
object_3488.finish();
}
if let Some(var_3489) = &input.count {
#[allow(unused_mut)]
let mut object_3490 = object.key("Count").start_object();
crate::json_ser::serialize_structure_crate_model_aws_wafv2_rules_action_count_details(
&mut object_3490,
var_3489,
)?;
object_3490.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_occurrences(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Occurrences,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3491) = &input.line_ranges {
let mut array_3492 = object.key("LineRanges").start_array();
for item_3493 in var_3491 {
{
#[allow(unused_mut)]
let mut object_3494 = array_3492.value().start_object();
crate::json_ser::serialize_structure_crate_model_range(
&mut object_3494,
item_3493,
)?;
object_3494.finish();
}
}
array_3492.finish();
}
if let Some(var_3495) = &input.offset_ranges {
let mut array_3496 = object.key("OffsetRanges").start_array();
for item_3497 in var_3495 {
{
#[allow(unused_mut)]
let mut object_3498 = array_3496.value().start_object();
crate::json_ser::serialize_structure_crate_model_range(
&mut object_3498,
item_3497,
)?;
object_3498.finish();
}
}
array_3496.finish();
}
if let Some(var_3499) = &input.pages {
let mut array_3500 = object.key("Pages").start_array();
for item_3501 in var_3499 {
{
#[allow(unused_mut)]
let mut object_3502 = array_3500.value().start_object();
crate::json_ser::serialize_structure_crate_model_page(&mut object_3502, item_3501)?;
object_3502.finish();
}
}
array_3500.finish();
}
if let Some(var_3503) = &input.records {
let mut array_3504 = object.key("Records").start_array();
for item_3505 in var_3503 {
{
#[allow(unused_mut)]
let mut object_3506 = array_3504.value().start_object();
crate::json_ser::serialize_structure_crate_model_record(
&mut object_3506,
item_3505,
)?;
object_3506.finish();
}
}
array_3504.finish();
}
if let Some(var_3507) = &input.cells {
let mut array_3508 = object.key("Cells").start_array();
for item_3509 in var_3507 {
{
#[allow(unused_mut)]
let mut object_3510 = array_3508.value().start_object();
crate::json_ser::serialize_structure_crate_model_cell(&mut object_3510, item_3509)?;
object_3510.finish();
}
}
array_3508.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_auto_scaling_auto_scaling_group_mixed_instances_policy_launch_template_launch_template_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsAutoScalingAutoScalingGroupMixedInstancesPolicyLaunchTemplateLaunchTemplateSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3511) = &input.launch_template_id {
object.key("LaunchTemplateId").string(var_3511.as_str());
}
if let Some(var_3512) = &input.launch_template_name {
object.key("LaunchTemplateName").string(var_3512.as_str());
}
if let Some(var_3513) = &input.version {
object.key("Version").string(var_3513.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_auto_scaling_auto_scaling_group_mixed_instances_policy_launch_template_overrides_list_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsAutoScalingAutoScalingGroupMixedInstancesPolicyLaunchTemplateOverridesListDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3514) = &input.instance_type {
object.key("InstanceType").string(var_3514.as_str());
}
if let Some(var_3515) = &input.weighted_capacity {
object.key("WeightedCapacity").string(var_3515.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_cloud_front_distribution_origin_s3_origin_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCloudFrontDistributionOriginS3OriginConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3516) = &input.origin_access_identity {
object.key("OriginAccessIdentity").string(var_3516.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_cloud_front_distribution_origin_custom_origin_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCloudFrontDistributionOriginCustomOriginConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.http_port != 0 {
object.key("HttpPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.http_port).into()),
);
}
if input.https_port != 0 {
object.key("HttpsPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.https_port).into()),
);
}
if input.origin_keepalive_timeout != 0 {
object.key("OriginKeepaliveTimeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.origin_keepalive_timeout).into()),
);
}
if let Some(var_3517) = &input.origin_protocol_policy {
object.key("OriginProtocolPolicy").string(var_3517.as_str());
}
if input.origin_read_timeout != 0 {
object.key("OriginReadTimeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.origin_read_timeout).into()),
);
}
if let Some(var_3518) = &input.origin_ssl_protocols {
#[allow(unused_mut)]
let mut object_3519 = object.key("OriginSslProtocols").start_object();
crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_origin_ssl_protocols(&mut object_3519, var_3518)?;
object_3519.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_cloud_front_distribution_origin_group_failover(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCloudFrontDistributionOriginGroupFailover,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3520) = &input.status_codes {
#[allow(unused_mut)]
let mut object_3521 = object.key("StatusCodes").start_object();
crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_origin_group_failover_status_codes(&mut object_3521, var_3520)?;
object_3521.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_server_side_encryption_by_default(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketServerSideEncryptionByDefault,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3522) = &input.sse_algorithm {
object.key("SSEAlgorithm").string(var_3522.as_str());
}
if let Some(var_3523) = &input.kms_master_key_id {
object.key("KMSMasterKeyID").string(var_3523.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_abort_incomplete_multipart_upload_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketBucketLifecycleConfigurationRulesAbortIncompleteMultipartUploadDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.days_after_initiation != 0 {
object.key("DaysAfterInitiation").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.days_after_initiation).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_filter_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketBucketLifecycleConfigurationRulesFilterDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3524) = &input.predicate {
#[allow(unused_mut)]
let mut object_3525 = object.key("Predicate").start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_filter_predicate_details(&mut object_3525, var_3524)?;
object_3525.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_noncurrent_version_transitions_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketBucketLifecycleConfigurationRulesNoncurrentVersionTransitionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.days != 0 {
object.key("Days").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.days).into()),
);
}
if let Some(var_3526) = &input.storage_class {
object.key("StorageClass").string(var_3526.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_transitions_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketBucketLifecycleConfigurationRulesTransitionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3527) = &input.date {
object.key("Date").string(var_3527.as_str());
}
if input.days != 0 {
object.key("Days").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.days).into()),
);
}
if let Some(var_3528) = &input.storage_class {
object.key("StorageClass").string(var_3528.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_website_configuration_routing_rule_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketWebsiteConfigurationRoutingRuleCondition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3529) = &input.http_error_code_returned_equals {
object
.key("HttpErrorCodeReturnedEquals")
.string(var_3529.as_str());
}
if let Some(var_3530) = &input.key_prefix_equals {
object.key("KeyPrefixEquals").string(var_3530.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_website_configuration_routing_rule_redirect(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketWebsiteConfigurationRoutingRuleRedirect,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3531) = &input.hostname {
object.key("Hostname").string(var_3531.as_str());
}
if let Some(var_3532) = &input.http_redirect_code {
object.key("HttpRedirectCode").string(var_3532.as_str());
}
if let Some(var_3533) = &input.protocol {
object.key("Protocol").string(var_3533.as_str());
}
if let Some(var_3534) = &input.replace_key_prefix_with {
object.key("ReplaceKeyPrefixWith").string(var_3534.as_str());
}
if let Some(var_3535) = &input.replace_key_with {
object.key("ReplaceKeyWith").string(var_3535.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_notification_configuration_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketNotificationConfigurationFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3536) = &input.s3_key_filter {
#[allow(unused_mut)]
let mut object_3537 = object.key("S3KeyFilter").start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_notification_configuration_s3_key_filter(&mut object_3537, var_3536)?;
object_3537.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_rds_db_subnet_group_subnet_availability_zone(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsRdsDbSubnetGroupSubnetAvailabilityZone,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3538) = &input.name {
object.key("Name").string(var_3538.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_cluster_configuration_execute_command_configuration_log_configuration_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsClusterConfigurationExecuteCommandConfigurationLogConfigurationDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.cloud_watch_encryption_enabled {
object
.key("CloudWatchEncryptionEnabled")
.boolean(input.cloud_watch_encryption_enabled);
}
if let Some(var_3539) = &input.cloud_watch_log_group_name {
object
.key("CloudWatchLogGroupName")
.string(var_3539.as_str());
}
if let Some(var_3540) = &input.s3_bucket_name {
object.key("S3BucketName").string(var_3540.as_str());
}
if input.s3_encryption_enabled {
object
.key("S3EncryptionEnabled")
.boolean(input.s3_encryption_enabled);
}
if let Some(var_3541) = &input.s3_key_prefix {
object.key("S3KeyPrefix").string(var_3541.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_linux_parameters_capabilities_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsLinuxParametersCapabilitiesDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3542) = &input.add {
let mut array_3543 = object.key("Add").start_array();
for item_3544 in var_3542 {
{
array_3543.value().string(item_3544.as_str());
}
}
array_3543.finish();
}
if let Some(var_3545) = &input.drop {
let mut array_3546 = object.key("Drop").start_array();
for item_3547 in var_3545 {
{
array_3546.value().string(item_3547.as_str());
}
}
array_3546.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_linux_parameters_devices_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsLinuxParametersDevicesDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3548) = &input.container_path {
object.key("ContainerPath").string(var_3548.as_str());
}
if let Some(var_3549) = &input.host_path {
object.key("HostPath").string(var_3549.as_str());
}
if let Some(var_3550) = &input.permissions {
let mut array_3551 = object.key("Permissions").start_array();
for item_3552 in var_3550 {
{
array_3551.value().string(item_3552.as_str());
}
}
array_3551.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_linux_parameters_tmpfs_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsLinuxParametersTmpfsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3553) = &input.container_path {
object.key("ContainerPath").string(var_3553.as_str());
}
if let Some(var_3554) = &input.mount_options {
let mut array_3555 = object.key("MountOptions").start_array();
for item_3556 in var_3554 {
{
array_3555.value().string(item_3556.as_str());
}
}
array_3555.finish();
}
if input.size != 0 {
object.key("Size").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.size).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_log_configuration_secret_options_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsLogConfigurationSecretOptionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3557) = &input.name {
object.key("Name").string(var_3557.as_str());
}
if let Some(var_3558) = &input.value_from {
object.key("ValueFrom").string(var_3558.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ecs_task_definition_volumes_efs_volume_configuration_authorization_config_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEcsTaskDefinitionVolumesEfsVolumeConfigurationAuthorizationConfigDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3559) = &input.access_point_id {
object.key("AccessPointId").string(var_3559.as_str());
}
if let Some(var_3560) = &input.iam {
object.key("Iam").string(var_3560.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_stateless_custom_action_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StatelessCustomActionDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3561) = &input.publish_metric_action {
#[allow(unused_mut)]
let mut object_3562 = object.key("PublishMetricAction").start_object();
crate::json_ser::serialize_structure_crate_model_stateless_custom_publish_metric_action(
&mut object_3562,
var_3561,
)?;
object_3562.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_group_variables_ip_sets_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleGroupVariablesIpSetsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3563) = &input.definition {
let mut array_3564 = object.key("Definition").start_array();
for item_3565 in var_3563 {
{
array_3564.value().string(item_3565.as_str());
}
}
array_3564.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_group_variables_port_sets_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleGroupVariablesPortSetsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3566) = &input.definition {
let mut array_3567 = object.key("Definition").start_array();
for item_3568 in var_3566 {
{
array_3567.value().string(item_3568.as_str());
}
}
array_3567.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_group_source_list_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleGroupSourceListDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3569) = &input.generated_rules_type {
object.key("GeneratedRulesType").string(var_3569.as_str());
}
if let Some(var_3570) = &input.target_types {
let mut array_3571 = object.key("TargetTypes").start_array();
for item_3572 in var_3570 {
{
array_3571.value().string(item_3572.as_str());
}
}
array_3571.finish();
}
if let Some(var_3573) = &input.targets {
let mut array_3574 = object.key("Targets").start_array();
for item_3575 in var_3573 {
{
array_3574.value().string(item_3575.as_str());
}
}
array_3574.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_group_source_stateful_rules_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleGroupSourceStatefulRulesDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3576) = &input.action {
object.key("Action").string(var_3576.as_str());
}
if let Some(var_3577) = &input.header {
#[allow(unused_mut)]
let mut object_3578 = object.key("Header").start_object();
crate::json_ser::serialize_structure_crate_model_rule_group_source_stateful_rules_header_details(&mut object_3578, var_3577)?;
object_3578.finish();
}
if let Some(var_3579) = &input.rule_options {
let mut array_3580 = object.key("RuleOptions").start_array();
for item_3581 in var_3579 {
{
#[allow(unused_mut)]
let mut object_3582 = array_3580.value().start_object();
crate::json_ser::serialize_structure_crate_model_rule_group_source_stateful_rules_options_details(&mut object_3582, item_3581)?;
object_3582.finish();
}
}
array_3580.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_group_source_stateless_rules_and_custom_actions_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleGroupSourceStatelessRulesAndCustomActionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3583) = &input.custom_actions {
let mut array_3584 = object.key("CustomActions").start_array();
for item_3585 in var_3583 {
{
#[allow(unused_mut)]
let mut object_3586 = array_3584.value().start_object();
crate::json_ser::serialize_structure_crate_model_rule_group_source_custom_actions_details(&mut object_3586, item_3585)?;
object_3586.finish();
}
}
array_3584.finish();
}
if let Some(var_3587) = &input.stateless_rules {
let mut array_3588 = object.key("StatelessRules").start_array();
for item_3589 in var_3587 {
{
#[allow(unused_mut)]
let mut object_3590 = array_3588.value().start_object();
crate::json_ser::serialize_structure_crate_model_rule_group_source_stateless_rules_details(&mut object_3590, item_3589)?;
object_3590.finish();
}
}
array_3588.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_backup_backup_plan_rule_copy_actions_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsBackupBackupPlanRuleCopyActionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3591) = &input.destination_backup_vault_arn {
object
.key("DestinationBackupVaultArn")
.string(var_3591.as_str());
}
if let Some(var_3592) = &input.lifecycle {
#[allow(unused_mut)]
let mut object_3593 = object.key("Lifecycle").start_object();
crate::json_ser::serialize_structure_crate_model_aws_backup_backup_plan_lifecycle_details(
&mut object_3593,
var_3592,
)?;
object_3593.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_backup_backup_plan_lifecycle_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsBackupBackupPlanLifecycleDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.delete_after_days != 0 {
object.key("DeleteAfterDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.delete_after_days).into()),
);
}
if input.move_to_cold_storage_after_days != 0 {
object.key("MoveToColdStorageAfterDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.move_to_cold_storage_after_days).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_block_device_mapping_set_ebs_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataBlockDeviceMappingSetEbsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.delete_on_termination {
object
.key("DeleteOnTermination")
.boolean(input.delete_on_termination);
}
if input.encrypted {
object.key("Encrypted").boolean(input.encrypted);
}
if input.iops != 0 {
object.key("Iops").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.iops).into()),
);
}
if let Some(var_3594) = &input.kms_key_id {
object.key("KmsKeyId").string(var_3594.as_str());
}
if let Some(var_3595) = &input.snapshot_id {
object.key("SnapshotId").string(var_3595.as_str());
}
if input.throughput != 0 {
object.key("Throughput").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.throughput).into()),
);
}
if input.volume_size != 0 {
object.key("VolumeSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.volume_size).into()),
);
}
if let Some(var_3596) = &input.volume_type {
object.key("VolumeType").string(var_3596.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_capacity_reservation_specification_capacity_reservation_target_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataCapacityReservationSpecificationCapacityReservationTargetDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3597) = &input.capacity_reservation_id {
object
.key("CapacityReservationId")
.string(var_3597.as_str());
}
if let Some(var_3598) = &input.capacity_reservation_resource_group_arn {
object
.key("CapacityReservationResourceGroupArn")
.string(var_3598.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_instance_market_options_spot_options_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataInstanceMarketOptionsSpotOptionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.block_duration_minutes != 0 {
object.key("BlockDurationMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.block_duration_minutes).into()),
);
}
if let Some(var_3599) = &input.instance_interruption_behavior {
object
.key("InstanceInterruptionBehavior")
.string(var_3599.as_str());
}
if let Some(var_3600) = &input.max_price {
object.key("MaxPrice").string(var_3600.as_str());
}
if let Some(var_3601) = &input.spot_instance_type {
object.key("SpotInstanceType").string(var_3601.as_str());
}
if let Some(var_3602) = &input.valid_until {
object.key("ValidUntil").string(var_3602.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_instance_requirements_accelerator_count_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataInstanceRequirementsAcceleratorCountDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.max != 0 {
object.key("Max").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max).into()),
);
}
if input.min != 0 {
object.key("Min").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.min).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_instance_requirements_accelerator_total_memory_mi_b_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataInstanceRequirementsAcceleratorTotalMemoryMiBDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.max != 0 {
object.key("Max").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max).into()),
);
}
if input.min != 0 {
object.key("Min").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.min).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_instance_requirements_baseline_ebs_bandwidth_mbps_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataInstanceRequirementsBaselineEbsBandwidthMbpsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.max != 0 {
object.key("Max").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max).into()),
);
}
if input.min != 0 {
object.key("Min").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.min).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_instance_requirements_memory_gi_b_per_v_cpu_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataInstanceRequirementsMemoryGiBPerVCpuDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.max != 0.0 {
object.key("Max").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.max).into()),
);
}
if input.min != 0.0 {
object.key("Min").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.min).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_instance_requirements_memory_mi_b_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataInstanceRequirementsMemoryMiBDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.max != 0 {
object.key("Max").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max).into()),
);
}
if input.min != 0 {
object.key("Min").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.min).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_instance_requirements_network_interface_count_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataInstanceRequirementsNetworkInterfaceCountDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.max != 0 {
object.key("Max").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max).into()),
);
}
if input.min != 0 {
object.key("Min").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.min).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_instance_requirements_total_local_storage_gb_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataInstanceRequirementsTotalLocalStorageGbDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.max != 0.0 {
object.key("Max").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.max).into()),
);
}
if input.min != 0.0 {
object.key("Min").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.min).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_instance_requirements_v_cpu_count_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataInstanceRequirementsVCpuCountDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.max != 0 {
object.key("Max").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max).into()),
);
}
if input.min != 0 {
object.key("Min").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.min).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_network_interface_set_ipv4_prefixes_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataNetworkInterfaceSetIpv4PrefixesDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3603) = &input.ipv4_prefix {
object.key("Ipv4Prefix").string(var_3603.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_network_interface_set_ipv6_addresses_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataNetworkInterfaceSetIpv6AddressesDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3604) = &input.ipv6_address {
object.key("Ipv6Address").string(var_3604.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_network_interface_set_ipv6_prefixes_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataNetworkInterfaceSetIpv6PrefixesDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3605) = &input.ipv6_prefix {
object.key("Ipv6Prefix").string(var_3605.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_ec2_launch_template_data_network_interface_set_private_ip_addresses_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsEc2LaunchTemplateDataNetworkInterfaceSetPrivateIpAddressesDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.primary {
object.key("Primary").boolean(input.primary);
}
if let Some(var_3606) = &input.private_ip_address {
object.key("PrivateIpAddress").string(var_3606.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_wafv2_custom_request_handling_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafv2CustomRequestHandlingDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3607) = &input.insert_headers {
let mut array_3608 = object.key("InsertHeaders").start_array();
for item_3609 in var_3607 {
{
#[allow(unused_mut)]
let mut object_3610 = array_3608.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_wafv2_custom_http_header(
&mut object_3610,
item_3609,
)?;
object_3610.finish();
}
}
array_3608.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_wafv2_custom_response_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafv2CustomResponseDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3611) = &input.custom_response_body_key {
object
.key("CustomResponseBodyKey")
.string(var_3611.as_str());
}
if input.response_code != 0 {
object.key("ResponseCode").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.response_code).into()),
);
}
if let Some(var_3612) = &input.response_headers {
let mut array_3613 = object.key("ResponseHeaders").start_array();
for item_3614 in var_3612 {
{
#[allow(unused_mut)]
let mut object_3615 = array_3613.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_wafv2_custom_http_header(
&mut object_3615,
item_3614,
)?;
object_3615.finish();
}
}
array_3613.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_wafv2_rules_action_captcha_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafv2RulesActionCaptchaDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3616) = &input.custom_request_handling {
#[allow(unused_mut)]
let mut object_3617 = object.key("CustomRequestHandling").start_object();
crate::json_ser::serialize_structure_crate_model_aws_wafv2_custom_request_handling_details(
&mut object_3617,
var_3616,
)?;
object_3617.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_wafv2_rules_action_count_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafv2RulesActionCountDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3618) = &input.custom_request_handling {
#[allow(unused_mut)]
let mut object_3619 = object.key("CustomRequestHandling").start_object();
crate::json_ser::serialize_structure_crate_model_aws_wafv2_custom_request_handling_details(
&mut object_3619,
var_3618,
)?;
object_3619.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Range,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.start != 0 {
object.key("Start").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.start).into()),
);
}
if input.end != 0 {
object.key("End").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.end).into()),
);
}
if input.start_column != 0 {
object.key("StartColumn").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.start_column).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_page(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Page,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.page_number != 0 {
object.key("PageNumber").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.page_number).into()),
);
}
if let Some(var_3620) = &input.line_range {
#[allow(unused_mut)]
let mut object_3621 = object.key("LineRange").start_object();
crate::json_ser::serialize_structure_crate_model_range(&mut object_3621, var_3620)?;
object_3621.finish();
}
if let Some(var_3622) = &input.offset_range {
#[allow(unused_mut)]
let mut object_3623 = object.key("OffsetRange").start_object();
crate::json_ser::serialize_structure_crate_model_range(&mut object_3623, var_3622)?;
object_3623.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_record(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Record,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3624) = &input.json_path {
object.key("JsonPath").string(var_3624.as_str());
}
if input.record_index != 0 {
object.key("RecordIndex").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.record_index).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_cell(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Cell,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.column != 0 {
object.key("Column").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.column).into()),
);
}
if input.row != 0 {
object.key("Row").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.row).into()),
);
}
if let Some(var_3625) = &input.column_name {
object.key("ColumnName").string(var_3625.as_str());
}
if let Some(var_3626) = &input.cell_reference {
object.key("CellReference").string(var_3626.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_cloud_front_distribution_origin_ssl_protocols(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCloudFrontDistributionOriginSslProtocols,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3627) = &input.items {
let mut array_3628 = object.key("Items").start_array();
for item_3629 in var_3627 {
{
array_3628.value().string(item_3629.as_str());
}
}
array_3628.finish();
}
if input.quantity != 0 {
object.key("Quantity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.quantity).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_cloud_front_distribution_origin_group_failover_status_codes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsCloudFrontDistributionOriginGroupFailoverStatusCodes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3630) = &input.items {
let mut array_3631 = object.key("Items").start_array();
for item_3632 in var_3630 {
{
array_3631.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*item_3632).into()),
);
}
}
array_3631.finish();
}
if input.quantity != 0 {
object.key("Quantity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.quantity).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_filter_predicate_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketBucketLifecycleConfigurationRulesFilterPredicateDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3633) = &input.operands {
let mut array_3634 = object.key("Operands").start_array();
for item_3635 in var_3633 {
{
#[allow(unused_mut)]
let mut object_3636 = array_3634.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_filter_predicate_operands_details(&mut object_3636, item_3635)?;
object_3636.finish();
}
}
array_3634.finish();
}
if let Some(var_3637) = &input.prefix {
object.key("Prefix").string(var_3637.as_str());
}
if let Some(var_3638) = &input.tag {
#[allow(unused_mut)]
let mut object_3639 = object.key("Tag").start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_filter_predicate_tag_details(&mut object_3639, var_3638)?;
object_3639.finish();
}
if let Some(var_3640) = &input.r#type {
object.key("Type").string(var_3640.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_notification_configuration_s3_key_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketNotificationConfigurationS3KeyFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3641) = &input.filter_rules {
let mut array_3642 = object.key("FilterRules").start_array();
for item_3643 in var_3641 {
{
#[allow(unused_mut)]
let mut object_3644 = array_3642.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_notification_configuration_s3_key_filter_rule(&mut object_3644, item_3643)?;
object_3644.finish();
}
}
array_3642.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_stateless_custom_publish_metric_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StatelessCustomPublishMetricAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3645) = &input.dimensions {
let mut array_3646 = object.key("Dimensions").start_array();
for item_3647 in var_3645 {
{
#[allow(unused_mut)]
let mut object_3648 = array_3646.value().start_object();
crate::json_ser::serialize_structure_crate_model_stateless_custom_publish_metric_action_dimension(&mut object_3648, item_3647)?;
object_3648.finish();
}
}
array_3646.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_group_source_stateful_rules_header_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleGroupSourceStatefulRulesHeaderDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3649) = &input.destination {
object.key("Destination").string(var_3649.as_str());
}
if let Some(var_3650) = &input.destination_port {
object.key("DestinationPort").string(var_3650.as_str());
}
if let Some(var_3651) = &input.direction {
object.key("Direction").string(var_3651.as_str());
}
if let Some(var_3652) = &input.protocol {
object.key("Protocol").string(var_3652.as_str());
}
if let Some(var_3653) = &input.source {
object.key("Source").string(var_3653.as_str());
}
if let Some(var_3654) = &input.source_port {
object.key("SourcePort").string(var_3654.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_group_source_stateful_rules_options_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleGroupSourceStatefulRulesOptionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3655) = &input.keyword {
object.key("Keyword").string(var_3655.as_str());
}
if let Some(var_3656) = &input.settings {
let mut array_3657 = object.key("Settings").start_array();
for item_3658 in var_3656 {
{
array_3657.value().string(item_3658.as_str());
}
}
array_3657.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_group_source_custom_actions_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleGroupSourceCustomActionsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3659) = &input.action_definition {
#[allow(unused_mut)]
let mut object_3660 = object.key("ActionDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_stateless_custom_action_definition(
&mut object_3660,
var_3659,
)?;
object_3660.finish();
}
if let Some(var_3661) = &input.action_name {
object.key("ActionName").string(var_3661.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_group_source_stateless_rules_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleGroupSourceStatelessRulesDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.priority != 0 {
object.key("Priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.priority).into()),
);
}
if let Some(var_3662) = &input.rule_definition {
#[allow(unused_mut)]
let mut object_3663 = object.key("RuleDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_rule_group_source_stateless_rule_definition(&mut object_3663, var_3662)?;
object_3663.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_wafv2_custom_http_header(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsWafv2CustomHttpHeader,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3664) = &input.name {
object.key("Name").string(var_3664.as_str());
}
if let Some(var_3665) = &input.value {
object.key("Value").string(var_3665.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_filter_predicate_operands_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketBucketLifecycleConfigurationRulesFilterPredicateOperandsDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3666) = &input.prefix {
object.key("Prefix").string(var_3666.as_str());
}
if let Some(var_3667) = &input.tag {
#[allow(unused_mut)]
let mut object_3668 = object.key("Tag").start_object();
crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_filter_predicate_operands_tag_details(&mut object_3668, var_3667)?;
object_3668.finish();
}
if let Some(var_3669) = &input.r#type {
object.key("Type").string(var_3669.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_filter_predicate_tag_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketBucketLifecycleConfigurationRulesFilterPredicateTagDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3670) = &input.key {
object.key("Key").string(var_3670.as_str());
}
if let Some(var_3671) = &input.value {
object.key("Value").string(var_3671.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_notification_configuration_s3_key_filter_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketNotificationConfigurationS3KeyFilterRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3672) = &input.name {
object.key("Name").string(var_3672.as_str());
}
if let Some(var_3673) = &input.value {
object.key("Value").string(var_3673.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_stateless_custom_publish_metric_action_dimension(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StatelessCustomPublishMetricActionDimension,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3674) = &input.value {
object.key("Value").string(var_3674.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_group_source_stateless_rule_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleGroupSourceStatelessRuleDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3675) = &input.actions {
let mut array_3676 = object.key("Actions").start_array();
for item_3677 in var_3675 {
{
array_3676.value().string(item_3677.as_str());
}
}
array_3676.finish();
}
if let Some(var_3678) = &input.match_attributes {
#[allow(unused_mut)]
let mut object_3679 = object.key("MatchAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_rule_group_source_stateless_rule_match_attributes(&mut object_3679, var_3678)?;
object_3679.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_filter_predicate_operands_tag_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsS3BucketBucketLifecycleConfigurationRulesFilterPredicateOperandsTagDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3680) = &input.key {
object.key("Key").string(var_3680.as_str());
}
if let Some(var_3681) = &input.value {
object.key("Value").string(var_3681.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_group_source_stateless_rule_match_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleGroupSourceStatelessRuleMatchAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3682) = &input.destination_ports {
let mut array_3683 = object.key("DestinationPorts").start_array();
for item_3684 in var_3682 {
{
#[allow(unused_mut)]
let mut object_3685 = array_3683.value().start_object();
crate::json_ser::serialize_structure_crate_model_rule_group_source_stateless_rule_match_attributes_destination_ports(&mut object_3685, item_3684)?;
object_3685.finish();
}
}
array_3683.finish();
}
if let Some(var_3686) = &input.destinations {
let mut array_3687 = object.key("Destinations").start_array();
for item_3688 in var_3686 {
{
#[allow(unused_mut)]
let mut object_3689 = array_3687.value().start_object();
crate::json_ser::serialize_structure_crate_model_rule_group_source_stateless_rule_match_attributes_destinations(&mut object_3689, item_3688)?;
object_3689.finish();
}
}
array_3687.finish();
}
if let Some(var_3690) = &input.protocols {
let mut array_3691 = object.key("Protocols").start_array();
for item_3692 in var_3690 {
{
array_3691.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*item_3692).into()),
);
}
}
array_3691.finish();
}
if let Some(var_3693) = &input.source_ports {
let mut array_3694 = object.key("SourcePorts").start_array();
for item_3695 in var_3693 {
{
#[allow(unused_mut)]
let mut object_3696 = array_3694.value().start_object();
crate::json_ser::serialize_structure_crate_model_rule_group_source_stateless_rule_match_attributes_source_ports(&mut object_3696, item_3695)?;
object_3696.finish();
}
}
array_3694.finish();
}
if let Some(var_3697) = &input.sources {
let mut array_3698 = object.key("Sources").start_array();
for item_3699 in var_3697 {
{
#[allow(unused_mut)]
let mut object_3700 = array_3698.value().start_object();
crate::json_ser::serialize_structure_crate_model_rule_group_source_stateless_rule_match_attributes_sources(&mut object_3700, item_3699)?;
object_3700.finish();
}
}
array_3698.finish();
}
if let Some(var_3701) = &input.tcp_flags {
let mut array_3702 = object.key("TcpFlags").start_array();
for item_3703 in var_3701 {
{
#[allow(unused_mut)]
let mut object_3704 = array_3702.value().start_object();
crate::json_ser::serialize_structure_crate_model_rule_group_source_stateless_rule_match_attributes_tcp_flags(&mut object_3704, item_3703)?;
object_3704.finish();
}
}
array_3702.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_group_source_stateless_rule_match_attributes_destination_ports(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleGroupSourceStatelessRuleMatchAttributesDestinationPorts,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.from_port != 0 {
object.key("FromPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.from_port).into()),
);
}
if input.to_port != 0 {
object.key("ToPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.to_port).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_group_source_stateless_rule_match_attributes_destinations(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleGroupSourceStatelessRuleMatchAttributesDestinations,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3705) = &input.address_definition {
object.key("AddressDefinition").string(var_3705.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_group_source_stateless_rule_match_attributes_source_ports(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleGroupSourceStatelessRuleMatchAttributesSourcePorts,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.from_port != 0 {
object.key("FromPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.from_port).into()),
);
}
if input.to_port != 0 {
object.key("ToPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.to_port).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_group_source_stateless_rule_match_attributes_sources(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleGroupSourceStatelessRuleMatchAttributesSources,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3706) = &input.address_definition {
object.key("AddressDefinition").string(var_3706.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_group_source_stateless_rule_match_attributes_tcp_flags(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleGroupSourceStatelessRuleMatchAttributesTcpFlags,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3707) = &input.flags {
let mut array_3708 = object.key("Flags").start_array();
for item_3709 in var_3707 {
{
array_3708.value().string(item_3709.as_str());
}
}
array_3708.finish();
}
if let Some(var_3710) = &input.masks {
let mut array_3711 = object.key("Masks").start_array();
for item_3712 in var_3710 {
{
array_3711.value().string(item_3712.as_str());
}
}
array_3711.finish();
}
Ok(())
}