#[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::error::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::error::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::error::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::error::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::error::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::error::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::error::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();
}
#[allow(unused_mut)]
let mut scope_56 = writer.prefix("AccountFilterType");
if let Some(var_57) = &input.account_filter_type {
scope_56.string(var_57.as_str());
}
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::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_58 = writer.prefix("RegionConcurrencyType");
if let Some(var_59) = &input.region_concurrency_type {
scope_58.string(var_59.as_str());
}
#[allow(unused_mut)]
let mut scope_60 = writer.prefix("RegionOrder");
if let Some(var_61) = &input.region_order {
let mut list_63 = scope_60.start_list(false, None);
for item_62 in var_61 {
#[allow(unused_mut)]
let mut entry_64 = list_63.entry();
entry_64.string(item_62);
}
list_63.finish();
}
#[allow(unused_mut)]
let mut scope_65 = writer.prefix("FailureToleranceCount");
if let Some(var_66) = &input.failure_tolerance_count {
scope_65.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_66).into()),
);
}
#[allow(unused_mut)]
let mut scope_67 = writer.prefix("FailureTolerancePercentage");
if let Some(var_68) = &input.failure_tolerance_percentage {
scope_67.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_68).into()),
);
}
#[allow(unused_mut)]
let mut scope_69 = writer.prefix("MaxConcurrentCount");
if let Some(var_70) = &input.max_concurrent_count {
scope_69.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_70).into()),
);
}
#[allow(unused_mut)]
let mut scope_71 = writer.prefix("MaxConcurrentPercentage");
if let Some(var_72) = &input.max_concurrent_percentage {
scope_71.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_72).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::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_73 = writer.prefix("Enabled");
if let Some(var_74) = &input.enabled {
scope_73.boolean(*var_74);
}
#[allow(unused_mut)]
let mut scope_75 = writer.prefix("RetainStacksOnAccountRemoval");
if let Some(var_76) = &input.retain_stacks_on_account_removal {
scope_75.boolean(*var_76);
}
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::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_77 = writer.prefix("Active");
if let Some(var_78) = &input.active {
scope_77.boolean(*var_78);
}
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::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_79 = writer.prefix("Name");
if let Some(var_80) = &input.name {
scope_79.string(var_80.as_str());
}
#[allow(unused_mut)]
let mut scope_81 = writer.prefix("Values");
if let Some(var_82) = &input.values {
scope_81.string(var_82);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_operation_result_filter(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::OperationResultFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_83 = writer.prefix("Name");
if let Some(var_84) = &input.name {
scope_83.string(var_84.as_str());
}
#[allow(unused_mut)]
let mut scope_85 = writer.prefix("Values");
if let Some(var_86) = &input.values {
scope_85.string(var_86);
}
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::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_87 = writer.prefix("Category");
if let Some(var_88) = &input.category {
scope_87.string(var_88.as_str());
}
#[allow(unused_mut)]
let mut scope_89 = writer.prefix("PublisherId");
if let Some(var_90) = &input.publisher_id {
scope_89.string(var_90);
}
#[allow(unused_mut)]
let mut scope_91 = writer.prefix("TypeNamePrefix");
if let Some(var_92) = &input.type_name_prefix {
scope_91.string(var_92);
}
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::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_93 = writer.prefix("Arn");
if let Some(var_94) = &input.arn {
scope_93.string(var_94);
}
#[allow(unused_mut)]
let mut scope_95 = writer.prefix("Type");
if let Some(var_96) = &input.r#type {
scope_95.string(var_96);
}
Ok(())
}