aws-sdk-cloudformation 0.14.0

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_logging_config(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LoggingConfig,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1 = writer.prefix("LogRoleArn");
    if let Some(var_2) = &input.log_role_arn {
        scope_1.string(var_2);
    }
    #[allow(unused_mut)]
    let mut scope_3 = writer.prefix("LogGroupName");
    if let Some(var_4) = &input.log_group_name {
        scope_3.string(var_4);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_type_configuration_identifier(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::TypeConfigurationIdentifier,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_5 = writer.prefix("TypeArn");
    if let Some(var_6) = &input.type_arn {
        scope_5.string(var_6);
    }
    #[allow(unused_mut)]
    let mut scope_7 = writer.prefix("TypeConfigurationAlias");
    if let Some(var_8) = &input.type_configuration_alias {
        scope_7.string(var_8);
    }
    #[allow(unused_mut)]
    let mut scope_9 = writer.prefix("TypeConfigurationArn");
    if let Some(var_10) = &input.type_configuration_arn {
        scope_9.string(var_10);
    }
    #[allow(unused_mut)]
    let mut scope_11 = writer.prefix("Type");
    if let Some(var_12) = &input.r#type {
        scope_11.string(var_12.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_13 = writer.prefix("TypeName");
    if let Some(var_14) = &input.type_name {
        scope_13.string(var_14);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_parameter(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::Parameter,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_15 = writer.prefix("ParameterKey");
    if let Some(var_16) = &input.parameter_key {
        scope_15.string(var_16);
    }
    #[allow(unused_mut)]
    let mut scope_17 = writer.prefix("ParameterValue");
    if let Some(var_18) = &input.parameter_value {
        scope_17.string(var_18);
    }
    #[allow(unused_mut)]
    let mut scope_19 = writer.prefix("UsePreviousValue");
    if let Some(var_20) = &input.use_previous_value {
        scope_19.boolean(*var_20);
    }
    #[allow(unused_mut)]
    let mut scope_21 = writer.prefix("ResolvedValue");
    if let Some(var_22) = &input.resolved_value {
        scope_21.string(var_22);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_rollback_configuration(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::RollbackConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_23 = writer.prefix("RollbackTriggers");
    if let Some(var_24) = &input.rollback_triggers {
        let mut list_26 = scope_23.start_list(false, None);
        for item_25 in var_24 {
            #[allow(unused_mut)]
            let mut entry_27 = list_26.entry();
            crate::query_ser::serialize_structure_crate_model_rollback_trigger(entry_27, item_25)?;
        }
        list_26.finish();
    }
    #[allow(unused_mut)]
    let mut scope_28 = writer.prefix("MonitoringTimeInMinutes");
    if let Some(var_29) = &input.monitoring_time_in_minutes {
        scope_28.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_29).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_tag(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_30 = writer.prefix("Key");
    if let Some(var_31) = &input.key {
        scope_30.string(var_31);
    }
    #[allow(unused_mut)]
    let mut scope_32 = writer.prefix("Value");
    if let Some(var_33) = &input.value {
        scope_32.string(var_33);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_resource_to_import(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ResourceToImport,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_34 = writer.prefix("ResourceType");
    if let Some(var_35) = &input.resource_type {
        scope_34.string(var_35);
    }
    #[allow(unused_mut)]
    let mut scope_36 = writer.prefix("LogicalResourceId");
    if let Some(var_37) = &input.logical_resource_id {
        scope_36.string(var_37);
    }
    #[allow(unused_mut)]
    let mut scope_38 = writer.prefix("ResourceIdentifier");
    if let Some(var_39) = &input.resource_identifier {
        let mut map_40 = scope_38.start_map(false, "key", "value");
        for (key_41, value_42) in var_39 {
            #[allow(unused_mut)]
            let mut entry_43 = map_40.entry(key_41);
            {
                entry_43.string(value_42);
            }
        }
        map_40.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_deployment_targets(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::DeploymentTargets,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_44 = writer.prefix("Accounts");
    if let Some(var_45) = &input.accounts {
        let mut list_47 = scope_44.start_list(false, None);
        for item_46 in var_45 {
            #[allow(unused_mut)]
            let mut entry_48 = list_47.entry();
            entry_48.string(item_46);
        }
        list_47.finish();
    }
    #[allow(unused_mut)]
    let mut scope_49 = writer.prefix("AccountsUrl");
    if let Some(var_50) = &input.accounts_url {
        scope_49.string(var_50);
    }
    #[allow(unused_mut)]
    let mut scope_51 = writer.prefix("OrganizationalUnitIds");
    if let Some(var_52) = &input.organizational_unit_ids {
        let mut list_54 = scope_51.start_list(false, None);
        for item_53 in var_52 {
            #[allow(unused_mut)]
            let mut entry_55 = list_54.entry();
            entry_55.string(item_53);
        }
        list_54.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_stack_set_operation_preferences(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::StackSetOperationPreferences,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_56 = writer.prefix("RegionConcurrencyType");
    if let Some(var_57) = &input.region_concurrency_type {
        scope_56.string(var_57.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_58 = writer.prefix("RegionOrder");
    if let Some(var_59) = &input.region_order {
        let mut list_61 = scope_58.start_list(false, None);
        for item_60 in var_59 {
            #[allow(unused_mut)]
            let mut entry_62 = list_61.entry();
            entry_62.string(item_60);
        }
        list_61.finish();
    }
    #[allow(unused_mut)]
    let mut scope_63 = writer.prefix("FailureToleranceCount");
    if let Some(var_64) = &input.failure_tolerance_count {
        scope_63.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_64).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_65 = writer.prefix("FailureTolerancePercentage");
    if let Some(var_66) = &input.failure_tolerance_percentage {
        scope_65.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_66).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_67 = writer.prefix("MaxConcurrentCount");
    if let Some(var_68) = &input.max_concurrent_count {
        scope_67.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_68).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_69 = writer.prefix("MaxConcurrentPercentage");
    if let Some(var_70) = &input.max_concurrent_percentage {
        scope_69.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_70).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_auto_deployment(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::AutoDeployment,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_71 = writer.prefix("Enabled");
    if let Some(var_72) = &input.enabled {
        scope_71.boolean(*var_72);
    }
    #[allow(unused_mut)]
    let mut scope_73 = writer.prefix("RetainStacksOnAccountRemoval");
    if let Some(var_74) = &input.retain_stacks_on_account_removal {
        scope_73.boolean(*var_74);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_managed_execution(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ManagedExecution,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_75 = writer.prefix("Active");
    if let Some(var_76) = &input.active {
        scope_75.boolean(*var_76);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_stack_instance_filter(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::StackInstanceFilter,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_77 = writer.prefix("Name");
    if let Some(var_78) = &input.name {
        scope_77.string(var_78.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_79 = writer.prefix("Values");
    if let Some(var_80) = &input.values {
        scope_79.string(var_80);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_type_filters(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::TypeFilters,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_81 = writer.prefix("Category");
    if let Some(var_82) = &input.category {
        scope_81.string(var_82.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_83 = writer.prefix("PublisherId");
    if let Some(var_84) = &input.publisher_id {
        scope_83.string(var_84);
    }
    #[allow(unused_mut)]
    let mut scope_85 = writer.prefix("TypeNamePrefix");
    if let Some(var_86) = &input.type_name_prefix {
        scope_85.string(var_86);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_rollback_trigger(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::RollbackTrigger,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_87 = writer.prefix("Arn");
    if let Some(var_88) = &input.arn {
        scope_87.string(var_88);
    }
    #[allow(unused_mut)]
    let mut scope_89 = writer.prefix("Type");
    if let Some(var_90) = &input.r#type {
        scope_89.string(var_90);
    }
    Ok(())
}