pub fn serialize_operation_crate_operation_activate_type(
input: &crate::input::ActivateTypeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ActivateType", "2010-05-15");
#[allow(unused_mut)]
let mut scope_1 = writer.prefix("Type");
if let Some(var_2) = &input.r#type {
scope_1.string(var_2.as_str());
}
#[allow(unused_mut)]
let mut scope_3 = writer.prefix("PublicTypeArn");
if let Some(var_4) = &input.public_type_arn {
scope_3.string(var_4);
}
#[allow(unused_mut)]
let mut scope_5 = writer.prefix("PublisherId");
if let Some(var_6) = &input.publisher_id {
scope_5.string(var_6);
}
#[allow(unused_mut)]
let mut scope_7 = writer.prefix("TypeName");
if let Some(var_8) = &input.type_name {
scope_7.string(var_8);
}
#[allow(unused_mut)]
let mut scope_9 = writer.prefix("TypeNameAlias");
if let Some(var_10) = &input.type_name_alias {
scope_9.string(var_10);
}
#[allow(unused_mut)]
let mut scope_11 = writer.prefix("AutoUpdate");
if let Some(var_12) = &input.auto_update {
scope_11.boolean(*var_12);
}
#[allow(unused_mut)]
let mut scope_13 = writer.prefix("LoggingConfig");
if let Some(var_14) = &input.logging_config {
crate::query_ser::serialize_structure_crate_model_logging_config(scope_13, var_14)?;
}
#[allow(unused_mut)]
let mut scope_15 = writer.prefix("ExecutionRoleArn");
if let Some(var_16) = &input.execution_role_arn {
scope_15.string(var_16);
}
#[allow(unused_mut)]
let mut scope_17 = writer.prefix("VersionBump");
if let Some(var_18) = &input.version_bump {
scope_17.string(var_18.as_str());
}
#[allow(unused_mut)]
let mut scope_19 = writer.prefix("MajorVersion");
if let Some(var_20) = &input.major_version {
scope_19.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_20).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_batch_describe_type_configurations(
input: &crate::input::BatchDescribeTypeConfigurationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"BatchDescribeTypeConfigurations",
"2010-05-15",
);
#[allow(unused_mut)]
let mut scope_21 = writer.prefix("TypeConfigurationIdentifiers");
if let Some(var_22) = &input.type_configuration_identifiers {
let mut list_24 = scope_21.start_list(false, None);
for item_23 in var_22 {
#[allow(unused_mut)]
let mut entry_25 = list_24.entry();
crate::query_ser::serialize_structure_crate_model_type_configuration_identifier(
entry_25, item_23,
)?;
}
list_24.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_cancel_update_stack(
input: &crate::input::CancelUpdateStackInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CancelUpdateStack", "2010-05-15");
#[allow(unused_mut)]
let mut scope_26 = writer.prefix("StackName");
if let Some(var_27) = &input.stack_name {
scope_26.string(var_27);
}
#[allow(unused_mut)]
let mut scope_28 = writer.prefix("ClientRequestToken");
if let Some(var_29) = &input.client_request_token {
scope_28.string(var_29);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_continue_update_rollback(
input: &crate::input::ContinueUpdateRollbackInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ContinueUpdateRollback", "2010-05-15");
#[allow(unused_mut)]
let mut scope_30 = writer.prefix("StackName");
if let Some(var_31) = &input.stack_name {
scope_30.string(var_31);
}
#[allow(unused_mut)]
let mut scope_32 = writer.prefix("RoleARN");
if let Some(var_33) = &input.role_arn {
scope_32.string(var_33);
}
#[allow(unused_mut)]
let mut scope_34 = writer.prefix("ResourcesToSkip");
if let Some(var_35) = &input.resources_to_skip {
let mut list_37 = scope_34.start_list(false, None);
for item_36 in var_35 {
#[allow(unused_mut)]
let mut entry_38 = list_37.entry();
entry_38.string(item_36);
}
list_37.finish();
}
#[allow(unused_mut)]
let mut scope_39 = writer.prefix("ClientRequestToken");
if let Some(var_40) = &input.client_request_token {
scope_39.string(var_40);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_change_set(
input: &crate::input::CreateChangeSetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateChangeSet", "2010-05-15");
#[allow(unused_mut)]
let mut scope_41 = writer.prefix("StackName");
if let Some(var_42) = &input.stack_name {
scope_41.string(var_42);
}
#[allow(unused_mut)]
let mut scope_43 = writer.prefix("TemplateBody");
if let Some(var_44) = &input.template_body {
scope_43.string(var_44);
}
#[allow(unused_mut)]
let mut scope_45 = writer.prefix("TemplateURL");
if let Some(var_46) = &input.template_url {
scope_45.string(var_46);
}
#[allow(unused_mut)]
let mut scope_47 = writer.prefix("UsePreviousTemplate");
if let Some(var_48) = &input.use_previous_template {
scope_47.boolean(*var_48);
}
#[allow(unused_mut)]
let mut scope_49 = writer.prefix("Parameters");
if let Some(var_50) = &input.parameters {
let mut list_52 = scope_49.start_list(false, None);
for item_51 in var_50 {
#[allow(unused_mut)]
let mut entry_53 = list_52.entry();
crate::query_ser::serialize_structure_crate_model_parameter(entry_53, item_51)?;
}
list_52.finish();
}
#[allow(unused_mut)]
let mut scope_54 = writer.prefix("Capabilities");
if let Some(var_55) = &input.capabilities {
let mut list_57 = scope_54.start_list(false, None);
for item_56 in var_55 {
#[allow(unused_mut)]
let mut entry_58 = list_57.entry();
entry_58.string(item_56.as_str());
}
list_57.finish();
}
#[allow(unused_mut)]
let mut scope_59 = writer.prefix("ResourceTypes");
if let Some(var_60) = &input.resource_types {
let mut list_62 = scope_59.start_list(false, None);
for item_61 in var_60 {
#[allow(unused_mut)]
let mut entry_63 = list_62.entry();
entry_63.string(item_61);
}
list_62.finish();
}
#[allow(unused_mut)]
let mut scope_64 = writer.prefix("RoleARN");
if let Some(var_65) = &input.role_arn {
scope_64.string(var_65);
}
#[allow(unused_mut)]
let mut scope_66 = writer.prefix("RollbackConfiguration");
if let Some(var_67) = &input.rollback_configuration {
crate::query_ser::serialize_structure_crate_model_rollback_configuration(scope_66, var_67)?;
}
#[allow(unused_mut)]
let mut scope_68 = writer.prefix("NotificationARNs");
if let Some(var_69) = &input.notification_ar_ns {
let mut list_71 = scope_68.start_list(false, None);
for item_70 in var_69 {
#[allow(unused_mut)]
let mut entry_72 = list_71.entry();
entry_72.string(item_70);
}
list_71.finish();
}
#[allow(unused_mut)]
let mut scope_73 = writer.prefix("Tags");
if let Some(var_74) = &input.tags {
let mut list_76 = scope_73.start_list(false, None);
for item_75 in var_74 {
#[allow(unused_mut)]
let mut entry_77 = list_76.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_77, item_75)?;
}
list_76.finish();
}
#[allow(unused_mut)]
let mut scope_78 = writer.prefix("ChangeSetName");
if let Some(var_79) = &input.change_set_name {
scope_78.string(var_79);
}
#[allow(unused_mut)]
let mut scope_80 = writer.prefix("ClientToken");
if let Some(var_81) = &input.client_token {
scope_80.string(var_81);
}
#[allow(unused_mut)]
let mut scope_82 = writer.prefix("Description");
if let Some(var_83) = &input.description {
scope_82.string(var_83);
}
#[allow(unused_mut)]
let mut scope_84 = writer.prefix("ChangeSetType");
if let Some(var_85) = &input.change_set_type {
scope_84.string(var_85.as_str());
}
#[allow(unused_mut)]
let mut scope_86 = writer.prefix("ResourcesToImport");
if let Some(var_87) = &input.resources_to_import {
let mut list_89 = scope_86.start_list(false, None);
for item_88 in var_87 {
#[allow(unused_mut)]
let mut entry_90 = list_89.entry();
crate::query_ser::serialize_structure_crate_model_resource_to_import(
entry_90, item_88,
)?;
}
list_89.finish();
}
#[allow(unused_mut)]
let mut scope_91 = writer.prefix("IncludeNestedStacks");
if let Some(var_92) = &input.include_nested_stacks {
scope_91.boolean(*var_92);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_stack(
input: &crate::input::CreateStackInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateStack", "2010-05-15");
#[allow(unused_mut)]
let mut scope_93 = writer.prefix("StackName");
if let Some(var_94) = &input.stack_name {
scope_93.string(var_94);
}
#[allow(unused_mut)]
let mut scope_95 = writer.prefix("TemplateBody");
if let Some(var_96) = &input.template_body {
scope_95.string(var_96);
}
#[allow(unused_mut)]
let mut scope_97 = writer.prefix("TemplateURL");
if let Some(var_98) = &input.template_url {
scope_97.string(var_98);
}
#[allow(unused_mut)]
let mut scope_99 = writer.prefix("Parameters");
if let Some(var_100) = &input.parameters {
let mut list_102 = scope_99.start_list(false, None);
for item_101 in var_100 {
#[allow(unused_mut)]
let mut entry_103 = list_102.entry();
crate::query_ser::serialize_structure_crate_model_parameter(entry_103, item_101)?;
}
list_102.finish();
}
#[allow(unused_mut)]
let mut scope_104 = writer.prefix("DisableRollback");
if let Some(var_105) = &input.disable_rollback {
scope_104.boolean(*var_105);
}
#[allow(unused_mut)]
let mut scope_106 = writer.prefix("RollbackConfiguration");
if let Some(var_107) = &input.rollback_configuration {
crate::query_ser::serialize_structure_crate_model_rollback_configuration(
scope_106, var_107,
)?;
}
#[allow(unused_mut)]
let mut scope_108 = writer.prefix("TimeoutInMinutes");
if let Some(var_109) = &input.timeout_in_minutes {
scope_108.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_109).into()),
);
}
#[allow(unused_mut)]
let mut scope_110 = writer.prefix("NotificationARNs");
if let Some(var_111) = &input.notification_ar_ns {
let mut list_113 = scope_110.start_list(false, None);
for item_112 in var_111 {
#[allow(unused_mut)]
let mut entry_114 = list_113.entry();
entry_114.string(item_112);
}
list_113.finish();
}
#[allow(unused_mut)]
let mut scope_115 = writer.prefix("Capabilities");
if let Some(var_116) = &input.capabilities {
let mut list_118 = scope_115.start_list(false, None);
for item_117 in var_116 {
#[allow(unused_mut)]
let mut entry_119 = list_118.entry();
entry_119.string(item_117.as_str());
}
list_118.finish();
}
#[allow(unused_mut)]
let mut scope_120 = writer.prefix("ResourceTypes");
if let Some(var_121) = &input.resource_types {
let mut list_123 = scope_120.start_list(false, None);
for item_122 in var_121 {
#[allow(unused_mut)]
let mut entry_124 = list_123.entry();
entry_124.string(item_122);
}
list_123.finish();
}
#[allow(unused_mut)]
let mut scope_125 = writer.prefix("RoleARN");
if let Some(var_126) = &input.role_arn {
scope_125.string(var_126);
}
#[allow(unused_mut)]
let mut scope_127 = writer.prefix("OnFailure");
if let Some(var_128) = &input.on_failure {
scope_127.string(var_128.as_str());
}
#[allow(unused_mut)]
let mut scope_129 = writer.prefix("StackPolicyBody");
if let Some(var_130) = &input.stack_policy_body {
scope_129.string(var_130);
}
#[allow(unused_mut)]
let mut scope_131 = writer.prefix("StackPolicyURL");
if let Some(var_132) = &input.stack_policy_url {
scope_131.string(var_132);
}
#[allow(unused_mut)]
let mut scope_133 = writer.prefix("Tags");
if let Some(var_134) = &input.tags {
let mut list_136 = scope_133.start_list(false, None);
for item_135 in var_134 {
#[allow(unused_mut)]
let mut entry_137 = list_136.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_137, item_135)?;
}
list_136.finish();
}
#[allow(unused_mut)]
let mut scope_138 = writer.prefix("ClientRequestToken");
if let Some(var_139) = &input.client_request_token {
scope_138.string(var_139);
}
#[allow(unused_mut)]
let mut scope_140 = writer.prefix("EnableTerminationProtection");
if let Some(var_141) = &input.enable_termination_protection {
scope_140.boolean(*var_141);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_stack_instances(
input: &crate::input::CreateStackInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateStackInstances", "2010-05-15");
#[allow(unused_mut)]
let mut scope_142 = writer.prefix("StackSetName");
if let Some(var_143) = &input.stack_set_name {
scope_142.string(var_143);
}
#[allow(unused_mut)]
let mut scope_144 = writer.prefix("Accounts");
if let Some(var_145) = &input.accounts {
let mut list_147 = scope_144.start_list(false, None);
for item_146 in var_145 {
#[allow(unused_mut)]
let mut entry_148 = list_147.entry();
entry_148.string(item_146);
}
list_147.finish();
}
#[allow(unused_mut)]
let mut scope_149 = writer.prefix("DeploymentTargets");
if let Some(var_150) = &input.deployment_targets {
crate::query_ser::serialize_structure_crate_model_deployment_targets(scope_149, var_150)?;
}
#[allow(unused_mut)]
let mut scope_151 = writer.prefix("Regions");
if let Some(var_152) = &input.regions {
let mut list_154 = scope_151.start_list(false, None);
for item_153 in var_152 {
#[allow(unused_mut)]
let mut entry_155 = list_154.entry();
entry_155.string(item_153);
}
list_154.finish();
}
#[allow(unused_mut)]
let mut scope_156 = writer.prefix("ParameterOverrides");
if let Some(var_157) = &input.parameter_overrides {
let mut list_159 = scope_156.start_list(false, None);
for item_158 in var_157 {
#[allow(unused_mut)]
let mut entry_160 = list_159.entry();
crate::query_ser::serialize_structure_crate_model_parameter(entry_160, item_158)?;
}
list_159.finish();
}
#[allow(unused_mut)]
let mut scope_161 = writer.prefix("OperationPreferences");
if let Some(var_162) = &input.operation_preferences {
crate::query_ser::serialize_structure_crate_model_stack_set_operation_preferences(
scope_161, var_162,
)?;
}
#[allow(unused_mut)]
let mut scope_163 = writer.prefix("OperationId");
if let Some(var_164) = &input.operation_id {
scope_163.string(var_164);
}
#[allow(unused_mut)]
let mut scope_165 = writer.prefix("CallAs");
if let Some(var_166) = &input.call_as {
scope_165.string(var_166.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_stack_set(
input: &crate::input::CreateStackSetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateStackSet", "2010-05-15");
#[allow(unused_mut)]
let mut scope_167 = writer.prefix("StackSetName");
if let Some(var_168) = &input.stack_set_name {
scope_167.string(var_168);
}
#[allow(unused_mut)]
let mut scope_169 = writer.prefix("Description");
if let Some(var_170) = &input.description {
scope_169.string(var_170);
}
#[allow(unused_mut)]
let mut scope_171 = writer.prefix("TemplateBody");
if let Some(var_172) = &input.template_body {
scope_171.string(var_172);
}
#[allow(unused_mut)]
let mut scope_173 = writer.prefix("TemplateURL");
if let Some(var_174) = &input.template_url {
scope_173.string(var_174);
}
#[allow(unused_mut)]
let mut scope_175 = writer.prefix("StackId");
if let Some(var_176) = &input.stack_id {
scope_175.string(var_176);
}
#[allow(unused_mut)]
let mut scope_177 = writer.prefix("Parameters");
if let Some(var_178) = &input.parameters {
let mut list_180 = scope_177.start_list(false, None);
for item_179 in var_178 {
#[allow(unused_mut)]
let mut entry_181 = list_180.entry();
crate::query_ser::serialize_structure_crate_model_parameter(entry_181, item_179)?;
}
list_180.finish();
}
#[allow(unused_mut)]
let mut scope_182 = writer.prefix("Capabilities");
if let Some(var_183) = &input.capabilities {
let mut list_185 = scope_182.start_list(false, None);
for item_184 in var_183 {
#[allow(unused_mut)]
let mut entry_186 = list_185.entry();
entry_186.string(item_184.as_str());
}
list_185.finish();
}
#[allow(unused_mut)]
let mut scope_187 = writer.prefix("Tags");
if let Some(var_188) = &input.tags {
let mut list_190 = scope_187.start_list(false, None);
for item_189 in var_188 {
#[allow(unused_mut)]
let mut entry_191 = list_190.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_191, item_189)?;
}
list_190.finish();
}
#[allow(unused_mut)]
let mut scope_192 = writer.prefix("AdministrationRoleARN");
if let Some(var_193) = &input.administration_role_arn {
scope_192.string(var_193);
}
#[allow(unused_mut)]
let mut scope_194 = writer.prefix("ExecutionRoleName");
if let Some(var_195) = &input.execution_role_name {
scope_194.string(var_195);
}
#[allow(unused_mut)]
let mut scope_196 = writer.prefix("PermissionModel");
if let Some(var_197) = &input.permission_model {
scope_196.string(var_197.as_str());
}
#[allow(unused_mut)]
let mut scope_198 = writer.prefix("AutoDeployment");
if let Some(var_199) = &input.auto_deployment {
crate::query_ser::serialize_structure_crate_model_auto_deployment(scope_198, var_199)?;
}
#[allow(unused_mut)]
let mut scope_200 = writer.prefix("CallAs");
if let Some(var_201) = &input.call_as {
scope_200.string(var_201.as_str());
}
#[allow(unused_mut)]
let mut scope_202 = writer.prefix("ClientRequestToken");
if let Some(var_203) = &input.client_request_token {
scope_202.string(var_203);
}
#[allow(unused_mut)]
let mut scope_204 = writer.prefix("ManagedExecution");
if let Some(var_205) = &input.managed_execution {
crate::query_ser::serialize_structure_crate_model_managed_execution(scope_204, var_205)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_deactivate_type(
input: &crate::input::DeactivateTypeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeactivateType", "2010-05-15");
#[allow(unused_mut)]
let mut scope_206 = writer.prefix("TypeName");
if let Some(var_207) = &input.type_name {
scope_206.string(var_207);
}
#[allow(unused_mut)]
let mut scope_208 = writer.prefix("Type");
if let Some(var_209) = &input.r#type {
scope_208.string(var_209.as_str());
}
#[allow(unused_mut)]
let mut scope_210 = writer.prefix("Arn");
if let Some(var_211) = &input.arn {
scope_210.string(var_211);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_change_set(
input: &crate::input::DeleteChangeSetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteChangeSet", "2010-05-15");
#[allow(unused_mut)]
let mut scope_212 = writer.prefix("ChangeSetName");
if let Some(var_213) = &input.change_set_name {
scope_212.string(var_213);
}
#[allow(unused_mut)]
let mut scope_214 = writer.prefix("StackName");
if let Some(var_215) = &input.stack_name {
scope_214.string(var_215);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_stack(
input: &crate::input::DeleteStackInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteStack", "2010-05-15");
#[allow(unused_mut)]
let mut scope_216 = writer.prefix("StackName");
if let Some(var_217) = &input.stack_name {
scope_216.string(var_217);
}
#[allow(unused_mut)]
let mut scope_218 = writer.prefix("RetainResources");
if let Some(var_219) = &input.retain_resources {
let mut list_221 = scope_218.start_list(false, None);
for item_220 in var_219 {
#[allow(unused_mut)]
let mut entry_222 = list_221.entry();
entry_222.string(item_220);
}
list_221.finish();
}
#[allow(unused_mut)]
let mut scope_223 = writer.prefix("RoleARN");
if let Some(var_224) = &input.role_arn {
scope_223.string(var_224);
}
#[allow(unused_mut)]
let mut scope_225 = writer.prefix("ClientRequestToken");
if let Some(var_226) = &input.client_request_token {
scope_225.string(var_226);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_stack_instances(
input: &crate::input::DeleteStackInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteStackInstances", "2010-05-15");
#[allow(unused_mut)]
let mut scope_227 = writer.prefix("StackSetName");
if let Some(var_228) = &input.stack_set_name {
scope_227.string(var_228);
}
#[allow(unused_mut)]
let mut scope_229 = writer.prefix("Accounts");
if let Some(var_230) = &input.accounts {
let mut list_232 = scope_229.start_list(false, None);
for item_231 in var_230 {
#[allow(unused_mut)]
let mut entry_233 = list_232.entry();
entry_233.string(item_231);
}
list_232.finish();
}
#[allow(unused_mut)]
let mut scope_234 = writer.prefix("DeploymentTargets");
if let Some(var_235) = &input.deployment_targets {
crate::query_ser::serialize_structure_crate_model_deployment_targets(scope_234, var_235)?;
}
#[allow(unused_mut)]
let mut scope_236 = writer.prefix("Regions");
if let Some(var_237) = &input.regions {
let mut list_239 = scope_236.start_list(false, None);
for item_238 in var_237 {
#[allow(unused_mut)]
let mut entry_240 = list_239.entry();
entry_240.string(item_238);
}
list_239.finish();
}
#[allow(unused_mut)]
let mut scope_241 = writer.prefix("OperationPreferences");
if let Some(var_242) = &input.operation_preferences {
crate::query_ser::serialize_structure_crate_model_stack_set_operation_preferences(
scope_241, var_242,
)?;
}
#[allow(unused_mut)]
let mut scope_243 = writer.prefix("RetainStacks");
{
scope_243.boolean(input.retain_stacks);
}
#[allow(unused_mut)]
let mut scope_244 = writer.prefix("OperationId");
if let Some(var_245) = &input.operation_id {
scope_244.string(var_245);
}
#[allow(unused_mut)]
let mut scope_246 = writer.prefix("CallAs");
if let Some(var_247) = &input.call_as {
scope_246.string(var_247.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_stack_set(
input: &crate::input::DeleteStackSetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteStackSet", "2010-05-15");
#[allow(unused_mut)]
let mut scope_248 = writer.prefix("StackSetName");
if let Some(var_249) = &input.stack_set_name {
scope_248.string(var_249);
}
#[allow(unused_mut)]
let mut scope_250 = writer.prefix("CallAs");
if let Some(var_251) = &input.call_as {
scope_250.string(var_251.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_deregister_type(
input: &crate::input::DeregisterTypeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeregisterType", "2010-05-15");
#[allow(unused_mut)]
let mut scope_252 = writer.prefix("Arn");
if let Some(var_253) = &input.arn {
scope_252.string(var_253);
}
#[allow(unused_mut)]
let mut scope_254 = writer.prefix("Type");
if let Some(var_255) = &input.r#type {
scope_254.string(var_255.as_str());
}
#[allow(unused_mut)]
let mut scope_256 = writer.prefix("TypeName");
if let Some(var_257) = &input.type_name {
scope_256.string(var_257);
}
#[allow(unused_mut)]
let mut scope_258 = writer.prefix("VersionId");
if let Some(var_259) = &input.version_id {
scope_258.string(var_259);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_account_limits(
input: &crate::input::DescribeAccountLimitsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeAccountLimits", "2010-05-15");
#[allow(unused_mut)]
let mut scope_260 = writer.prefix("NextToken");
if let Some(var_261) = &input.next_token {
scope_260.string(var_261);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_change_set(
input: &crate::input::DescribeChangeSetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeChangeSet", "2010-05-15");
#[allow(unused_mut)]
let mut scope_262 = writer.prefix("ChangeSetName");
if let Some(var_263) = &input.change_set_name {
scope_262.string(var_263);
}
#[allow(unused_mut)]
let mut scope_264 = writer.prefix("StackName");
if let Some(var_265) = &input.stack_name {
scope_264.string(var_265);
}
#[allow(unused_mut)]
let mut scope_266 = writer.prefix("NextToken");
if let Some(var_267) = &input.next_token {
scope_266.string(var_267);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_change_set_hooks(
input: &crate::input::DescribeChangeSetHooksInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeChangeSetHooks", "2010-05-15");
#[allow(unused_mut)]
let mut scope_268 = writer.prefix("ChangeSetName");
if let Some(var_269) = &input.change_set_name {
scope_268.string(var_269);
}
#[allow(unused_mut)]
let mut scope_270 = writer.prefix("StackName");
if let Some(var_271) = &input.stack_name {
scope_270.string(var_271);
}
#[allow(unused_mut)]
let mut scope_272 = writer.prefix("NextToken");
if let Some(var_273) = &input.next_token {
scope_272.string(var_273);
}
#[allow(unused_mut)]
let mut scope_274 = writer.prefix("LogicalResourceId");
if let Some(var_275) = &input.logical_resource_id {
scope_274.string(var_275);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_publisher(
input: &crate::input::DescribePublisherInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribePublisher", "2010-05-15");
#[allow(unused_mut)]
let mut scope_276 = writer.prefix("PublisherId");
if let Some(var_277) = &input.publisher_id {
scope_276.string(var_277);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_stack_drift_detection_status(
input: &crate::input::DescribeStackDriftDetectionStatusInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeStackDriftDetectionStatus",
"2010-05-15",
);
#[allow(unused_mut)]
let mut scope_278 = writer.prefix("StackDriftDetectionId");
if let Some(var_279) = &input.stack_drift_detection_id {
scope_278.string(var_279);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_stack_events(
input: &crate::input::DescribeStackEventsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeStackEvents", "2010-05-15");
#[allow(unused_mut)]
let mut scope_280 = writer.prefix("StackName");
if let Some(var_281) = &input.stack_name {
scope_280.string(var_281);
}
#[allow(unused_mut)]
let mut scope_282 = writer.prefix("NextToken");
if let Some(var_283) = &input.next_token {
scope_282.string(var_283);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_stack_instance(
input: &crate::input::DescribeStackInstanceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeStackInstance", "2010-05-15");
#[allow(unused_mut)]
let mut scope_284 = writer.prefix("StackSetName");
if let Some(var_285) = &input.stack_set_name {
scope_284.string(var_285);
}
#[allow(unused_mut)]
let mut scope_286 = writer.prefix("StackInstanceAccount");
if let Some(var_287) = &input.stack_instance_account {
scope_286.string(var_287);
}
#[allow(unused_mut)]
let mut scope_288 = writer.prefix("StackInstanceRegion");
if let Some(var_289) = &input.stack_instance_region {
scope_288.string(var_289);
}
#[allow(unused_mut)]
let mut scope_290 = writer.prefix("CallAs");
if let Some(var_291) = &input.call_as {
scope_290.string(var_291.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_stack_resource(
input: &crate::input::DescribeStackResourceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeStackResource", "2010-05-15");
#[allow(unused_mut)]
let mut scope_292 = writer.prefix("StackName");
if let Some(var_293) = &input.stack_name {
scope_292.string(var_293);
}
#[allow(unused_mut)]
let mut scope_294 = writer.prefix("LogicalResourceId");
if let Some(var_295) = &input.logical_resource_id {
scope_294.string(var_295);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_stack_resource_drifts(
input: &crate::input::DescribeStackResourceDriftsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeStackResourceDrifts", "2010-05-15");
#[allow(unused_mut)]
let mut scope_296 = writer.prefix("StackName");
if let Some(var_297) = &input.stack_name {
scope_296.string(var_297);
}
#[allow(unused_mut)]
let mut scope_298 = writer.prefix("StackResourceDriftStatusFilters");
if let Some(var_299) = &input.stack_resource_drift_status_filters {
let mut list_301 = scope_298.start_list(false, None);
for item_300 in var_299 {
#[allow(unused_mut)]
let mut entry_302 = list_301.entry();
entry_302.string(item_300.as_str());
}
list_301.finish();
}
#[allow(unused_mut)]
let mut scope_303 = writer.prefix("NextToken");
if let Some(var_304) = &input.next_token {
scope_303.string(var_304);
}
#[allow(unused_mut)]
let mut scope_305 = writer.prefix("MaxResults");
if let Some(var_306) = &input.max_results {
scope_305.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_306).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_stack_resources(
input: &crate::input::DescribeStackResourcesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeStackResources", "2010-05-15");
#[allow(unused_mut)]
let mut scope_307 = writer.prefix("StackName");
if let Some(var_308) = &input.stack_name {
scope_307.string(var_308);
}
#[allow(unused_mut)]
let mut scope_309 = writer.prefix("LogicalResourceId");
if let Some(var_310) = &input.logical_resource_id {
scope_309.string(var_310);
}
#[allow(unused_mut)]
let mut scope_311 = writer.prefix("PhysicalResourceId");
if let Some(var_312) = &input.physical_resource_id {
scope_311.string(var_312);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_stacks(
input: &crate::input::DescribeStacksInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeStacks", "2010-05-15");
#[allow(unused_mut)]
let mut scope_313 = writer.prefix("StackName");
if let Some(var_314) = &input.stack_name {
scope_313.string(var_314);
}
#[allow(unused_mut)]
let mut scope_315 = writer.prefix("NextToken");
if let Some(var_316) = &input.next_token {
scope_315.string(var_316);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_stack_set(
input: &crate::input::DescribeStackSetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeStackSet", "2010-05-15");
#[allow(unused_mut)]
let mut scope_317 = writer.prefix("StackSetName");
if let Some(var_318) = &input.stack_set_name {
scope_317.string(var_318);
}
#[allow(unused_mut)]
let mut scope_319 = writer.prefix("CallAs");
if let Some(var_320) = &input.call_as {
scope_319.string(var_320.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_stack_set_operation(
input: &crate::input::DescribeStackSetOperationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeStackSetOperation", "2010-05-15");
#[allow(unused_mut)]
let mut scope_321 = writer.prefix("StackSetName");
if let Some(var_322) = &input.stack_set_name {
scope_321.string(var_322);
}
#[allow(unused_mut)]
let mut scope_323 = writer.prefix("OperationId");
if let Some(var_324) = &input.operation_id {
scope_323.string(var_324);
}
#[allow(unused_mut)]
let mut scope_325 = writer.prefix("CallAs");
if let Some(var_326) = &input.call_as {
scope_325.string(var_326.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_type(
input: &crate::input::DescribeTypeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeType", "2010-05-15");
#[allow(unused_mut)]
let mut scope_327 = writer.prefix("Type");
if let Some(var_328) = &input.r#type {
scope_327.string(var_328.as_str());
}
#[allow(unused_mut)]
let mut scope_329 = writer.prefix("TypeName");
if let Some(var_330) = &input.type_name {
scope_329.string(var_330);
}
#[allow(unused_mut)]
let mut scope_331 = writer.prefix("Arn");
if let Some(var_332) = &input.arn {
scope_331.string(var_332);
}
#[allow(unused_mut)]
let mut scope_333 = writer.prefix("VersionId");
if let Some(var_334) = &input.version_id {
scope_333.string(var_334);
}
#[allow(unused_mut)]
let mut scope_335 = writer.prefix("PublisherId");
if let Some(var_336) = &input.publisher_id {
scope_335.string(var_336);
}
#[allow(unused_mut)]
let mut scope_337 = writer.prefix("PublicVersionNumber");
if let Some(var_338) = &input.public_version_number {
scope_337.string(var_338);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_type_registration(
input: &crate::input::DescribeTypeRegistrationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeTypeRegistration", "2010-05-15");
#[allow(unused_mut)]
let mut scope_339 = writer.prefix("RegistrationToken");
if let Some(var_340) = &input.registration_token {
scope_339.string(var_340);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_detect_stack_drift(
input: &crate::input::DetectStackDriftInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DetectStackDrift", "2010-05-15");
#[allow(unused_mut)]
let mut scope_341 = writer.prefix("StackName");
if let Some(var_342) = &input.stack_name {
scope_341.string(var_342);
}
#[allow(unused_mut)]
let mut scope_343 = writer.prefix("LogicalResourceIds");
if let Some(var_344) = &input.logical_resource_ids {
let mut list_346 = scope_343.start_list(false, None);
for item_345 in var_344 {
#[allow(unused_mut)]
let mut entry_347 = list_346.entry();
entry_347.string(item_345);
}
list_346.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_detect_stack_resource_drift(
input: &crate::input::DetectStackResourceDriftInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DetectStackResourceDrift", "2010-05-15");
#[allow(unused_mut)]
let mut scope_348 = writer.prefix("StackName");
if let Some(var_349) = &input.stack_name {
scope_348.string(var_349);
}
#[allow(unused_mut)]
let mut scope_350 = writer.prefix("LogicalResourceId");
if let Some(var_351) = &input.logical_resource_id {
scope_350.string(var_351);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_detect_stack_set_drift(
input: &crate::input::DetectStackSetDriftInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DetectStackSetDrift", "2010-05-15");
#[allow(unused_mut)]
let mut scope_352 = writer.prefix("StackSetName");
if let Some(var_353) = &input.stack_set_name {
scope_352.string(var_353);
}
#[allow(unused_mut)]
let mut scope_354 = writer.prefix("OperationPreferences");
if let Some(var_355) = &input.operation_preferences {
crate::query_ser::serialize_structure_crate_model_stack_set_operation_preferences(
scope_354, var_355,
)?;
}
#[allow(unused_mut)]
let mut scope_356 = writer.prefix("OperationId");
if let Some(var_357) = &input.operation_id {
scope_356.string(var_357);
}
#[allow(unused_mut)]
let mut scope_358 = writer.prefix("CallAs");
if let Some(var_359) = &input.call_as {
scope_358.string(var_359.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_estimate_template_cost(
input: &crate::input::EstimateTemplateCostInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "EstimateTemplateCost", "2010-05-15");
#[allow(unused_mut)]
let mut scope_360 = writer.prefix("TemplateBody");
if let Some(var_361) = &input.template_body {
scope_360.string(var_361);
}
#[allow(unused_mut)]
let mut scope_362 = writer.prefix("TemplateURL");
if let Some(var_363) = &input.template_url {
scope_362.string(var_363);
}
#[allow(unused_mut)]
let mut scope_364 = writer.prefix("Parameters");
if let Some(var_365) = &input.parameters {
let mut list_367 = scope_364.start_list(false, None);
for item_366 in var_365 {
#[allow(unused_mut)]
let mut entry_368 = list_367.entry();
crate::query_ser::serialize_structure_crate_model_parameter(entry_368, item_366)?;
}
list_367.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_execute_change_set(
input: &crate::input::ExecuteChangeSetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ExecuteChangeSet", "2010-05-15");
#[allow(unused_mut)]
let mut scope_369 = writer.prefix("ChangeSetName");
if let Some(var_370) = &input.change_set_name {
scope_369.string(var_370);
}
#[allow(unused_mut)]
let mut scope_371 = writer.prefix("StackName");
if let Some(var_372) = &input.stack_name {
scope_371.string(var_372);
}
#[allow(unused_mut)]
let mut scope_373 = writer.prefix("ClientRequestToken");
if let Some(var_374) = &input.client_request_token {
scope_373.string(var_374);
}
#[allow(unused_mut)]
let mut scope_375 = writer.prefix("DisableRollback");
if let Some(var_376) = &input.disable_rollback {
scope_375.boolean(*var_376);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_stack_policy(
input: &crate::input::GetStackPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetStackPolicy", "2010-05-15");
#[allow(unused_mut)]
let mut scope_377 = writer.prefix("StackName");
if let Some(var_378) = &input.stack_name {
scope_377.string(var_378);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_template(
input: &crate::input::GetTemplateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetTemplate", "2010-05-15");
#[allow(unused_mut)]
let mut scope_379 = writer.prefix("StackName");
if let Some(var_380) = &input.stack_name {
scope_379.string(var_380);
}
#[allow(unused_mut)]
let mut scope_381 = writer.prefix("ChangeSetName");
if let Some(var_382) = &input.change_set_name {
scope_381.string(var_382);
}
#[allow(unused_mut)]
let mut scope_383 = writer.prefix("TemplateStage");
if let Some(var_384) = &input.template_stage {
scope_383.string(var_384.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_template_summary(
input: &crate::input::GetTemplateSummaryInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetTemplateSummary", "2010-05-15");
#[allow(unused_mut)]
let mut scope_385 = writer.prefix("TemplateBody");
if let Some(var_386) = &input.template_body {
scope_385.string(var_386);
}
#[allow(unused_mut)]
let mut scope_387 = writer.prefix("TemplateURL");
if let Some(var_388) = &input.template_url {
scope_387.string(var_388);
}
#[allow(unused_mut)]
let mut scope_389 = writer.prefix("StackName");
if let Some(var_390) = &input.stack_name {
scope_389.string(var_390);
}
#[allow(unused_mut)]
let mut scope_391 = writer.prefix("StackSetName");
if let Some(var_392) = &input.stack_set_name {
scope_391.string(var_392);
}
#[allow(unused_mut)]
let mut scope_393 = writer.prefix("CallAs");
if let Some(var_394) = &input.call_as {
scope_393.string(var_394.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_import_stacks_to_stack_set(
input: &crate::input::ImportStacksToStackSetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ImportStacksToStackSet", "2010-05-15");
#[allow(unused_mut)]
let mut scope_395 = writer.prefix("StackSetName");
if let Some(var_396) = &input.stack_set_name {
scope_395.string(var_396);
}
#[allow(unused_mut)]
let mut scope_397 = writer.prefix("StackIds");
if let Some(var_398) = &input.stack_ids {
let mut list_400 = scope_397.start_list(false, None);
for item_399 in var_398 {
#[allow(unused_mut)]
let mut entry_401 = list_400.entry();
entry_401.string(item_399);
}
list_400.finish();
}
#[allow(unused_mut)]
let mut scope_402 = writer.prefix("StackIdsUrl");
if let Some(var_403) = &input.stack_ids_url {
scope_402.string(var_403);
}
#[allow(unused_mut)]
let mut scope_404 = writer.prefix("OrganizationalUnitIds");
if let Some(var_405) = &input.organizational_unit_ids {
let mut list_407 = scope_404.start_list(false, None);
for item_406 in var_405 {
#[allow(unused_mut)]
let mut entry_408 = list_407.entry();
entry_408.string(item_406);
}
list_407.finish();
}
#[allow(unused_mut)]
let mut scope_409 = writer.prefix("OperationPreferences");
if let Some(var_410) = &input.operation_preferences {
crate::query_ser::serialize_structure_crate_model_stack_set_operation_preferences(
scope_409, var_410,
)?;
}
#[allow(unused_mut)]
let mut scope_411 = writer.prefix("OperationId");
if let Some(var_412) = &input.operation_id {
scope_411.string(var_412);
}
#[allow(unused_mut)]
let mut scope_413 = writer.prefix("CallAs");
if let Some(var_414) = &input.call_as {
scope_413.string(var_414.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_change_sets(
input: &crate::input::ListChangeSetsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListChangeSets", "2010-05-15");
#[allow(unused_mut)]
let mut scope_415 = writer.prefix("StackName");
if let Some(var_416) = &input.stack_name {
scope_415.string(var_416);
}
#[allow(unused_mut)]
let mut scope_417 = writer.prefix("NextToken");
if let Some(var_418) = &input.next_token {
scope_417.string(var_418);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_exports(
input: &crate::input::ListExportsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListExports", "2010-05-15");
#[allow(unused_mut)]
let mut scope_419 = writer.prefix("NextToken");
if let Some(var_420) = &input.next_token {
scope_419.string(var_420);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_imports(
input: &crate::input::ListImportsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListImports", "2010-05-15");
#[allow(unused_mut)]
let mut scope_421 = writer.prefix("ExportName");
if let Some(var_422) = &input.export_name {
scope_421.string(var_422);
}
#[allow(unused_mut)]
let mut scope_423 = writer.prefix("NextToken");
if let Some(var_424) = &input.next_token {
scope_423.string(var_424);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_stack_instances(
input: &crate::input::ListStackInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListStackInstances", "2010-05-15");
#[allow(unused_mut)]
let mut scope_425 = writer.prefix("StackSetName");
if let Some(var_426) = &input.stack_set_name {
scope_425.string(var_426);
}
#[allow(unused_mut)]
let mut scope_427 = writer.prefix("NextToken");
if let Some(var_428) = &input.next_token {
scope_427.string(var_428);
}
#[allow(unused_mut)]
let mut scope_429 = writer.prefix("MaxResults");
if let Some(var_430) = &input.max_results {
scope_429.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_430).into()),
);
}
#[allow(unused_mut)]
let mut scope_431 = writer.prefix("Filters");
if let Some(var_432) = &input.filters {
let mut list_434 = scope_431.start_list(false, None);
for item_433 in var_432 {
#[allow(unused_mut)]
let mut entry_435 = list_434.entry();
crate::query_ser::serialize_structure_crate_model_stack_instance_filter(
entry_435, item_433,
)?;
}
list_434.finish();
}
#[allow(unused_mut)]
let mut scope_436 = writer.prefix("StackInstanceAccount");
if let Some(var_437) = &input.stack_instance_account {
scope_436.string(var_437);
}
#[allow(unused_mut)]
let mut scope_438 = writer.prefix("StackInstanceRegion");
if let Some(var_439) = &input.stack_instance_region {
scope_438.string(var_439);
}
#[allow(unused_mut)]
let mut scope_440 = writer.prefix("CallAs");
if let Some(var_441) = &input.call_as {
scope_440.string(var_441.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_stack_resources(
input: &crate::input::ListStackResourcesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListStackResources", "2010-05-15");
#[allow(unused_mut)]
let mut scope_442 = writer.prefix("StackName");
if let Some(var_443) = &input.stack_name {
scope_442.string(var_443);
}
#[allow(unused_mut)]
let mut scope_444 = writer.prefix("NextToken");
if let Some(var_445) = &input.next_token {
scope_444.string(var_445);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_stacks(
input: &crate::input::ListStacksInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListStacks", "2010-05-15");
#[allow(unused_mut)]
let mut scope_446 = writer.prefix("NextToken");
if let Some(var_447) = &input.next_token {
scope_446.string(var_447);
}
#[allow(unused_mut)]
let mut scope_448 = writer.prefix("StackStatusFilter");
if let Some(var_449) = &input.stack_status_filter {
let mut list_451 = scope_448.start_list(false, None);
for item_450 in var_449 {
#[allow(unused_mut)]
let mut entry_452 = list_451.entry();
entry_452.string(item_450.as_str());
}
list_451.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_stack_set_operation_results(
input: &crate::input::ListStackSetOperationResultsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListStackSetOperationResults", "2010-05-15");
#[allow(unused_mut)]
let mut scope_453 = writer.prefix("StackSetName");
if let Some(var_454) = &input.stack_set_name {
scope_453.string(var_454);
}
#[allow(unused_mut)]
let mut scope_455 = writer.prefix("OperationId");
if let Some(var_456) = &input.operation_id {
scope_455.string(var_456);
}
#[allow(unused_mut)]
let mut scope_457 = writer.prefix("NextToken");
if let Some(var_458) = &input.next_token {
scope_457.string(var_458);
}
#[allow(unused_mut)]
let mut scope_459 = writer.prefix("MaxResults");
if let Some(var_460) = &input.max_results {
scope_459.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_460).into()),
);
}
#[allow(unused_mut)]
let mut scope_461 = writer.prefix("CallAs");
if let Some(var_462) = &input.call_as {
scope_461.string(var_462.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_stack_set_operations(
input: &crate::input::ListStackSetOperationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListStackSetOperations", "2010-05-15");
#[allow(unused_mut)]
let mut scope_463 = writer.prefix("StackSetName");
if let Some(var_464) = &input.stack_set_name {
scope_463.string(var_464);
}
#[allow(unused_mut)]
let mut scope_465 = writer.prefix("NextToken");
if let Some(var_466) = &input.next_token {
scope_465.string(var_466);
}
#[allow(unused_mut)]
let mut scope_467 = writer.prefix("MaxResults");
if let Some(var_468) = &input.max_results {
scope_467.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_468).into()),
);
}
#[allow(unused_mut)]
let mut scope_469 = writer.prefix("CallAs");
if let Some(var_470) = &input.call_as {
scope_469.string(var_470.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_stack_sets(
input: &crate::input::ListStackSetsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListStackSets", "2010-05-15");
#[allow(unused_mut)]
let mut scope_471 = writer.prefix("NextToken");
if let Some(var_472) = &input.next_token {
scope_471.string(var_472);
}
#[allow(unused_mut)]
let mut scope_473 = writer.prefix("MaxResults");
if let Some(var_474) = &input.max_results {
scope_473.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_474).into()),
);
}
#[allow(unused_mut)]
let mut scope_475 = writer.prefix("Status");
if let Some(var_476) = &input.status {
scope_475.string(var_476.as_str());
}
#[allow(unused_mut)]
let mut scope_477 = writer.prefix("CallAs");
if let Some(var_478) = &input.call_as {
scope_477.string(var_478.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_type_registrations(
input: &crate::input::ListTypeRegistrationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListTypeRegistrations", "2010-05-15");
#[allow(unused_mut)]
let mut scope_479 = writer.prefix("Type");
if let Some(var_480) = &input.r#type {
scope_479.string(var_480.as_str());
}
#[allow(unused_mut)]
let mut scope_481 = writer.prefix("TypeName");
if let Some(var_482) = &input.type_name {
scope_481.string(var_482);
}
#[allow(unused_mut)]
let mut scope_483 = writer.prefix("TypeArn");
if let Some(var_484) = &input.type_arn {
scope_483.string(var_484);
}
#[allow(unused_mut)]
let mut scope_485 = writer.prefix("RegistrationStatusFilter");
if let Some(var_486) = &input.registration_status_filter {
scope_485.string(var_486.as_str());
}
#[allow(unused_mut)]
let mut scope_487 = writer.prefix("MaxResults");
if let Some(var_488) = &input.max_results {
scope_487.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_488).into()),
);
}
#[allow(unused_mut)]
let mut scope_489 = writer.prefix("NextToken");
if let Some(var_490) = &input.next_token {
scope_489.string(var_490);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_types(
input: &crate::input::ListTypesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListTypes", "2010-05-15");
#[allow(unused_mut)]
let mut scope_491 = writer.prefix("Visibility");
if let Some(var_492) = &input.visibility {
scope_491.string(var_492.as_str());
}
#[allow(unused_mut)]
let mut scope_493 = writer.prefix("ProvisioningType");
if let Some(var_494) = &input.provisioning_type {
scope_493.string(var_494.as_str());
}
#[allow(unused_mut)]
let mut scope_495 = writer.prefix("DeprecatedStatus");
if let Some(var_496) = &input.deprecated_status {
scope_495.string(var_496.as_str());
}
#[allow(unused_mut)]
let mut scope_497 = writer.prefix("Type");
if let Some(var_498) = &input.r#type {
scope_497.string(var_498.as_str());
}
#[allow(unused_mut)]
let mut scope_499 = writer.prefix("Filters");
if let Some(var_500) = &input.filters {
crate::query_ser::serialize_structure_crate_model_type_filters(scope_499, var_500)?;
}
#[allow(unused_mut)]
let mut scope_501 = writer.prefix("MaxResults");
if let Some(var_502) = &input.max_results {
scope_501.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_502).into()),
);
}
#[allow(unused_mut)]
let mut scope_503 = writer.prefix("NextToken");
if let Some(var_504) = &input.next_token {
scope_503.string(var_504);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_type_versions(
input: &crate::input::ListTypeVersionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListTypeVersions", "2010-05-15");
#[allow(unused_mut)]
let mut scope_505 = writer.prefix("Type");
if let Some(var_506) = &input.r#type {
scope_505.string(var_506.as_str());
}
#[allow(unused_mut)]
let mut scope_507 = writer.prefix("TypeName");
if let Some(var_508) = &input.type_name {
scope_507.string(var_508);
}
#[allow(unused_mut)]
let mut scope_509 = writer.prefix("Arn");
if let Some(var_510) = &input.arn {
scope_509.string(var_510);
}
#[allow(unused_mut)]
let mut scope_511 = writer.prefix("MaxResults");
if let Some(var_512) = &input.max_results {
scope_511.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_512).into()),
);
}
#[allow(unused_mut)]
let mut scope_513 = writer.prefix("NextToken");
if let Some(var_514) = &input.next_token {
scope_513.string(var_514);
}
#[allow(unused_mut)]
let mut scope_515 = writer.prefix("DeprecatedStatus");
if let Some(var_516) = &input.deprecated_status {
scope_515.string(var_516.as_str());
}
#[allow(unused_mut)]
let mut scope_517 = writer.prefix("PublisherId");
if let Some(var_518) = &input.publisher_id {
scope_517.string(var_518);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_publish_type(
input: &crate::input::PublishTypeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "PublishType", "2010-05-15");
#[allow(unused_mut)]
let mut scope_519 = writer.prefix("Type");
if let Some(var_520) = &input.r#type {
scope_519.string(var_520.as_str());
}
#[allow(unused_mut)]
let mut scope_521 = writer.prefix("Arn");
if let Some(var_522) = &input.arn {
scope_521.string(var_522);
}
#[allow(unused_mut)]
let mut scope_523 = writer.prefix("TypeName");
if let Some(var_524) = &input.type_name {
scope_523.string(var_524);
}
#[allow(unused_mut)]
let mut scope_525 = writer.prefix("PublicVersionNumber");
if let Some(var_526) = &input.public_version_number {
scope_525.string(var_526);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_record_handler_progress(
input: &crate::input::RecordHandlerProgressInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RecordHandlerProgress", "2010-05-15");
#[allow(unused_mut)]
let mut scope_527 = writer.prefix("BearerToken");
if let Some(var_528) = &input.bearer_token {
scope_527.string(var_528);
}
#[allow(unused_mut)]
let mut scope_529 = writer.prefix("OperationStatus");
if let Some(var_530) = &input.operation_status {
scope_529.string(var_530.as_str());
}
#[allow(unused_mut)]
let mut scope_531 = writer.prefix("CurrentOperationStatus");
if let Some(var_532) = &input.current_operation_status {
scope_531.string(var_532.as_str());
}
#[allow(unused_mut)]
let mut scope_533 = writer.prefix("StatusMessage");
if let Some(var_534) = &input.status_message {
scope_533.string(var_534);
}
#[allow(unused_mut)]
let mut scope_535 = writer.prefix("ErrorCode");
if let Some(var_536) = &input.error_code {
scope_535.string(var_536.as_str());
}
#[allow(unused_mut)]
let mut scope_537 = writer.prefix("ResourceModel");
if let Some(var_538) = &input.resource_model {
scope_537.string(var_538);
}
#[allow(unused_mut)]
let mut scope_539 = writer.prefix("ClientRequestToken");
if let Some(var_540) = &input.client_request_token {
scope_539.string(var_540);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_register_publisher(
input: &crate::input::RegisterPublisherInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RegisterPublisher", "2010-05-15");
#[allow(unused_mut)]
let mut scope_541 = writer.prefix("AcceptTermsAndConditions");
if let Some(var_542) = &input.accept_terms_and_conditions {
scope_541.boolean(*var_542);
}
#[allow(unused_mut)]
let mut scope_543 = writer.prefix("ConnectionArn");
if let Some(var_544) = &input.connection_arn {
scope_543.string(var_544);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_register_type(
input: &crate::input::RegisterTypeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "RegisterType", "2010-05-15");
#[allow(unused_mut)]
let mut scope_545 = writer.prefix("Type");
if let Some(var_546) = &input.r#type {
scope_545.string(var_546.as_str());
}
#[allow(unused_mut)]
let mut scope_547 = writer.prefix("TypeName");
if let Some(var_548) = &input.type_name {
scope_547.string(var_548);
}
#[allow(unused_mut)]
let mut scope_549 = writer.prefix("SchemaHandlerPackage");
if let Some(var_550) = &input.schema_handler_package {
scope_549.string(var_550);
}
#[allow(unused_mut)]
let mut scope_551 = writer.prefix("LoggingConfig");
if let Some(var_552) = &input.logging_config {
crate::query_ser::serialize_structure_crate_model_logging_config(scope_551, var_552)?;
}
#[allow(unused_mut)]
let mut scope_553 = writer.prefix("ExecutionRoleArn");
if let Some(var_554) = &input.execution_role_arn {
scope_553.string(var_554);
}
#[allow(unused_mut)]
let mut scope_555 = writer.prefix("ClientRequestToken");
if let Some(var_556) = &input.client_request_token {
scope_555.string(var_556);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_rollback_stack(
input: &crate::input::RollbackStackInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "RollbackStack", "2010-05-15");
#[allow(unused_mut)]
let mut scope_557 = writer.prefix("StackName");
if let Some(var_558) = &input.stack_name {
scope_557.string(var_558);
}
#[allow(unused_mut)]
let mut scope_559 = writer.prefix("RoleARN");
if let Some(var_560) = &input.role_arn {
scope_559.string(var_560);
}
#[allow(unused_mut)]
let mut scope_561 = writer.prefix("ClientRequestToken");
if let Some(var_562) = &input.client_request_token {
scope_561.string(var_562);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_set_stack_policy(
input: &crate::input::SetStackPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "SetStackPolicy", "2010-05-15");
#[allow(unused_mut)]
let mut scope_563 = writer.prefix("StackName");
if let Some(var_564) = &input.stack_name {
scope_563.string(var_564);
}
#[allow(unused_mut)]
let mut scope_565 = writer.prefix("StackPolicyBody");
if let Some(var_566) = &input.stack_policy_body {
scope_565.string(var_566);
}
#[allow(unused_mut)]
let mut scope_567 = writer.prefix("StackPolicyURL");
if let Some(var_568) = &input.stack_policy_url {
scope_567.string(var_568);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_set_type_configuration(
input: &crate::input::SetTypeConfigurationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "SetTypeConfiguration", "2010-05-15");
#[allow(unused_mut)]
let mut scope_569 = writer.prefix("TypeArn");
if let Some(var_570) = &input.type_arn {
scope_569.string(var_570);
}
#[allow(unused_mut)]
let mut scope_571 = writer.prefix("Configuration");
if let Some(var_572) = &input.configuration {
scope_571.string(var_572);
}
#[allow(unused_mut)]
let mut scope_573 = writer.prefix("ConfigurationAlias");
if let Some(var_574) = &input.configuration_alias {
scope_573.string(var_574);
}
#[allow(unused_mut)]
let mut scope_575 = writer.prefix("TypeName");
if let Some(var_576) = &input.type_name {
scope_575.string(var_576);
}
#[allow(unused_mut)]
let mut scope_577 = writer.prefix("Type");
if let Some(var_578) = &input.r#type {
scope_577.string(var_578.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_set_type_default_version(
input: &crate::input::SetTypeDefaultVersionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "SetTypeDefaultVersion", "2010-05-15");
#[allow(unused_mut)]
let mut scope_579 = writer.prefix("Arn");
if let Some(var_580) = &input.arn {
scope_579.string(var_580);
}
#[allow(unused_mut)]
let mut scope_581 = writer.prefix("Type");
if let Some(var_582) = &input.r#type {
scope_581.string(var_582.as_str());
}
#[allow(unused_mut)]
let mut scope_583 = writer.prefix("TypeName");
if let Some(var_584) = &input.type_name {
scope_583.string(var_584);
}
#[allow(unused_mut)]
let mut scope_585 = writer.prefix("VersionId");
if let Some(var_586) = &input.version_id {
scope_585.string(var_586);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_signal_resource(
input: &crate::input::SignalResourceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "SignalResource", "2010-05-15");
#[allow(unused_mut)]
let mut scope_587 = writer.prefix("StackName");
if let Some(var_588) = &input.stack_name {
scope_587.string(var_588);
}
#[allow(unused_mut)]
let mut scope_589 = writer.prefix("LogicalResourceId");
if let Some(var_590) = &input.logical_resource_id {
scope_589.string(var_590);
}
#[allow(unused_mut)]
let mut scope_591 = writer.prefix("UniqueId");
if let Some(var_592) = &input.unique_id {
scope_591.string(var_592);
}
#[allow(unused_mut)]
let mut scope_593 = writer.prefix("Status");
if let Some(var_594) = &input.status {
scope_593.string(var_594.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_stop_stack_set_operation(
input: &crate::input::StopStackSetOperationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "StopStackSetOperation", "2010-05-15");
#[allow(unused_mut)]
let mut scope_595 = writer.prefix("StackSetName");
if let Some(var_596) = &input.stack_set_name {
scope_595.string(var_596);
}
#[allow(unused_mut)]
let mut scope_597 = writer.prefix("OperationId");
if let Some(var_598) = &input.operation_id {
scope_597.string(var_598);
}
#[allow(unused_mut)]
let mut scope_599 = writer.prefix("CallAs");
if let Some(var_600) = &input.call_as {
scope_599.string(var_600.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_test_type(
input: &crate::input::TestTypeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "TestType", "2010-05-15");
#[allow(unused_mut)]
let mut scope_601 = writer.prefix("Arn");
if let Some(var_602) = &input.arn {
scope_601.string(var_602);
}
#[allow(unused_mut)]
let mut scope_603 = writer.prefix("Type");
if let Some(var_604) = &input.r#type {
scope_603.string(var_604.as_str());
}
#[allow(unused_mut)]
let mut scope_605 = writer.prefix("TypeName");
if let Some(var_606) = &input.type_name {
scope_605.string(var_606);
}
#[allow(unused_mut)]
let mut scope_607 = writer.prefix("VersionId");
if let Some(var_608) = &input.version_id {
scope_607.string(var_608);
}
#[allow(unused_mut)]
let mut scope_609 = writer.prefix("LogDeliveryBucket");
if let Some(var_610) = &input.log_delivery_bucket {
scope_609.string(var_610);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_stack(
input: &crate::input::UpdateStackInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "UpdateStack", "2010-05-15");
#[allow(unused_mut)]
let mut scope_611 = writer.prefix("StackName");
if let Some(var_612) = &input.stack_name {
scope_611.string(var_612);
}
#[allow(unused_mut)]
let mut scope_613 = writer.prefix("TemplateBody");
if let Some(var_614) = &input.template_body {
scope_613.string(var_614);
}
#[allow(unused_mut)]
let mut scope_615 = writer.prefix("TemplateURL");
if let Some(var_616) = &input.template_url {
scope_615.string(var_616);
}
#[allow(unused_mut)]
let mut scope_617 = writer.prefix("UsePreviousTemplate");
if let Some(var_618) = &input.use_previous_template {
scope_617.boolean(*var_618);
}
#[allow(unused_mut)]
let mut scope_619 = writer.prefix("StackPolicyDuringUpdateBody");
if let Some(var_620) = &input.stack_policy_during_update_body {
scope_619.string(var_620);
}
#[allow(unused_mut)]
let mut scope_621 = writer.prefix("StackPolicyDuringUpdateURL");
if let Some(var_622) = &input.stack_policy_during_update_url {
scope_621.string(var_622);
}
#[allow(unused_mut)]
let mut scope_623 = writer.prefix("Parameters");
if let Some(var_624) = &input.parameters {
let mut list_626 = scope_623.start_list(false, None);
for item_625 in var_624 {
#[allow(unused_mut)]
let mut entry_627 = list_626.entry();
crate::query_ser::serialize_structure_crate_model_parameter(entry_627, item_625)?;
}
list_626.finish();
}
#[allow(unused_mut)]
let mut scope_628 = writer.prefix("Capabilities");
if let Some(var_629) = &input.capabilities {
let mut list_631 = scope_628.start_list(false, None);
for item_630 in var_629 {
#[allow(unused_mut)]
let mut entry_632 = list_631.entry();
entry_632.string(item_630.as_str());
}
list_631.finish();
}
#[allow(unused_mut)]
let mut scope_633 = writer.prefix("ResourceTypes");
if let Some(var_634) = &input.resource_types {
let mut list_636 = scope_633.start_list(false, None);
for item_635 in var_634 {
#[allow(unused_mut)]
let mut entry_637 = list_636.entry();
entry_637.string(item_635);
}
list_636.finish();
}
#[allow(unused_mut)]
let mut scope_638 = writer.prefix("RoleARN");
if let Some(var_639) = &input.role_arn {
scope_638.string(var_639);
}
#[allow(unused_mut)]
let mut scope_640 = writer.prefix("RollbackConfiguration");
if let Some(var_641) = &input.rollback_configuration {
crate::query_ser::serialize_structure_crate_model_rollback_configuration(
scope_640, var_641,
)?;
}
#[allow(unused_mut)]
let mut scope_642 = writer.prefix("StackPolicyBody");
if let Some(var_643) = &input.stack_policy_body {
scope_642.string(var_643);
}
#[allow(unused_mut)]
let mut scope_644 = writer.prefix("StackPolicyURL");
if let Some(var_645) = &input.stack_policy_url {
scope_644.string(var_645);
}
#[allow(unused_mut)]
let mut scope_646 = writer.prefix("NotificationARNs");
if let Some(var_647) = &input.notification_ar_ns {
let mut list_649 = scope_646.start_list(false, None);
for item_648 in var_647 {
#[allow(unused_mut)]
let mut entry_650 = list_649.entry();
entry_650.string(item_648);
}
list_649.finish();
}
#[allow(unused_mut)]
let mut scope_651 = writer.prefix("Tags");
if let Some(var_652) = &input.tags {
let mut list_654 = scope_651.start_list(false, None);
for item_653 in var_652 {
#[allow(unused_mut)]
let mut entry_655 = list_654.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_655, item_653)?;
}
list_654.finish();
}
#[allow(unused_mut)]
let mut scope_656 = writer.prefix("DisableRollback");
if let Some(var_657) = &input.disable_rollback {
scope_656.boolean(*var_657);
}
#[allow(unused_mut)]
let mut scope_658 = writer.prefix("ClientRequestToken");
if let Some(var_659) = &input.client_request_token {
scope_658.string(var_659);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_stack_instances(
input: &crate::input::UpdateStackInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "UpdateStackInstances", "2010-05-15");
#[allow(unused_mut)]
let mut scope_660 = writer.prefix("StackSetName");
if let Some(var_661) = &input.stack_set_name {
scope_660.string(var_661);
}
#[allow(unused_mut)]
let mut scope_662 = writer.prefix("Accounts");
if let Some(var_663) = &input.accounts {
let mut list_665 = scope_662.start_list(false, None);
for item_664 in var_663 {
#[allow(unused_mut)]
let mut entry_666 = list_665.entry();
entry_666.string(item_664);
}
list_665.finish();
}
#[allow(unused_mut)]
let mut scope_667 = writer.prefix("DeploymentTargets");
if let Some(var_668) = &input.deployment_targets {
crate::query_ser::serialize_structure_crate_model_deployment_targets(scope_667, var_668)?;
}
#[allow(unused_mut)]
let mut scope_669 = writer.prefix("Regions");
if let Some(var_670) = &input.regions {
let mut list_672 = scope_669.start_list(false, None);
for item_671 in var_670 {
#[allow(unused_mut)]
let mut entry_673 = list_672.entry();
entry_673.string(item_671);
}
list_672.finish();
}
#[allow(unused_mut)]
let mut scope_674 = writer.prefix("ParameterOverrides");
if let Some(var_675) = &input.parameter_overrides {
let mut list_677 = scope_674.start_list(false, None);
for item_676 in var_675 {
#[allow(unused_mut)]
let mut entry_678 = list_677.entry();
crate::query_ser::serialize_structure_crate_model_parameter(entry_678, item_676)?;
}
list_677.finish();
}
#[allow(unused_mut)]
let mut scope_679 = writer.prefix("OperationPreferences");
if let Some(var_680) = &input.operation_preferences {
crate::query_ser::serialize_structure_crate_model_stack_set_operation_preferences(
scope_679, var_680,
)?;
}
#[allow(unused_mut)]
let mut scope_681 = writer.prefix("OperationId");
if let Some(var_682) = &input.operation_id {
scope_681.string(var_682);
}
#[allow(unused_mut)]
let mut scope_683 = writer.prefix("CallAs");
if let Some(var_684) = &input.call_as {
scope_683.string(var_684.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_stack_set(
input: &crate::input::UpdateStackSetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "UpdateStackSet", "2010-05-15");
#[allow(unused_mut)]
let mut scope_685 = writer.prefix("StackSetName");
if let Some(var_686) = &input.stack_set_name {
scope_685.string(var_686);
}
#[allow(unused_mut)]
let mut scope_687 = writer.prefix("Description");
if let Some(var_688) = &input.description {
scope_687.string(var_688);
}
#[allow(unused_mut)]
let mut scope_689 = writer.prefix("TemplateBody");
if let Some(var_690) = &input.template_body {
scope_689.string(var_690);
}
#[allow(unused_mut)]
let mut scope_691 = writer.prefix("TemplateURL");
if let Some(var_692) = &input.template_url {
scope_691.string(var_692);
}
#[allow(unused_mut)]
let mut scope_693 = writer.prefix("UsePreviousTemplate");
if let Some(var_694) = &input.use_previous_template {
scope_693.boolean(*var_694);
}
#[allow(unused_mut)]
let mut scope_695 = writer.prefix("Parameters");
if let Some(var_696) = &input.parameters {
let mut list_698 = scope_695.start_list(false, None);
for item_697 in var_696 {
#[allow(unused_mut)]
let mut entry_699 = list_698.entry();
crate::query_ser::serialize_structure_crate_model_parameter(entry_699, item_697)?;
}
list_698.finish();
}
#[allow(unused_mut)]
let mut scope_700 = writer.prefix("Capabilities");
if let Some(var_701) = &input.capabilities {
let mut list_703 = scope_700.start_list(false, None);
for item_702 in var_701 {
#[allow(unused_mut)]
let mut entry_704 = list_703.entry();
entry_704.string(item_702.as_str());
}
list_703.finish();
}
#[allow(unused_mut)]
let mut scope_705 = writer.prefix("Tags");
if let Some(var_706) = &input.tags {
let mut list_708 = scope_705.start_list(false, None);
for item_707 in var_706 {
#[allow(unused_mut)]
let mut entry_709 = list_708.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_709, item_707)?;
}
list_708.finish();
}
#[allow(unused_mut)]
let mut scope_710 = writer.prefix("OperationPreferences");
if let Some(var_711) = &input.operation_preferences {
crate::query_ser::serialize_structure_crate_model_stack_set_operation_preferences(
scope_710, var_711,
)?;
}
#[allow(unused_mut)]
let mut scope_712 = writer.prefix("AdministrationRoleARN");
if let Some(var_713) = &input.administration_role_arn {
scope_712.string(var_713);
}
#[allow(unused_mut)]
let mut scope_714 = writer.prefix("ExecutionRoleName");
if let Some(var_715) = &input.execution_role_name {
scope_714.string(var_715);
}
#[allow(unused_mut)]
let mut scope_716 = writer.prefix("DeploymentTargets");
if let Some(var_717) = &input.deployment_targets {
crate::query_ser::serialize_structure_crate_model_deployment_targets(scope_716, var_717)?;
}
#[allow(unused_mut)]
let mut scope_718 = writer.prefix("PermissionModel");
if let Some(var_719) = &input.permission_model {
scope_718.string(var_719.as_str());
}
#[allow(unused_mut)]
let mut scope_720 = writer.prefix("AutoDeployment");
if let Some(var_721) = &input.auto_deployment {
crate::query_ser::serialize_structure_crate_model_auto_deployment(scope_720, var_721)?;
}
#[allow(unused_mut)]
let mut scope_722 = writer.prefix("OperationId");
if let Some(var_723) = &input.operation_id {
scope_722.string(var_723);
}
#[allow(unused_mut)]
let mut scope_724 = writer.prefix("Accounts");
if let Some(var_725) = &input.accounts {
let mut list_727 = scope_724.start_list(false, None);
for item_726 in var_725 {
#[allow(unused_mut)]
let mut entry_728 = list_727.entry();
entry_728.string(item_726);
}
list_727.finish();
}
#[allow(unused_mut)]
let mut scope_729 = writer.prefix("Regions");
if let Some(var_730) = &input.regions {
let mut list_732 = scope_729.start_list(false, None);
for item_731 in var_730 {
#[allow(unused_mut)]
let mut entry_733 = list_732.entry();
entry_733.string(item_731);
}
list_732.finish();
}
#[allow(unused_mut)]
let mut scope_734 = writer.prefix("CallAs");
if let Some(var_735) = &input.call_as {
scope_734.string(var_735.as_str());
}
#[allow(unused_mut)]
let mut scope_736 = writer.prefix("ManagedExecution");
if let Some(var_737) = &input.managed_execution {
crate::query_ser::serialize_structure_crate_model_managed_execution(scope_736, var_737)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_termination_protection(
input: &crate::input::UpdateTerminationProtectionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "UpdateTerminationProtection", "2010-05-15");
#[allow(unused_mut)]
let mut scope_738 = writer.prefix("EnableTerminationProtection");
if let Some(var_739) = &input.enable_termination_protection {
scope_738.boolean(*var_739);
}
#[allow(unused_mut)]
let mut scope_740 = writer.prefix("StackName");
if let Some(var_741) = &input.stack_name {
scope_740.string(var_741);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_validate_template(
input: &crate::input::ValidateTemplateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ValidateTemplate", "2010-05-15");
#[allow(unused_mut)]
let mut scope_742 = writer.prefix("TemplateBody");
if let Some(var_743) = &input.template_body {
scope_742.string(var_743);
}
#[allow(unused_mut)]
let mut scope_744 = writer.prefix("TemplateURL");
if let Some(var_745) = &input.template_url {
scope_744.string(var_745);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}