pub fn serialize_operation_crate_operation_activate_type(
input: &crate::input::ActivateTypeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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());
}
#[allow(unused_mut)]
let mut scope_463 = writer.prefix("Filters");
if let Some(var_464) = &input.filters {
let mut list_466 = scope_463.start_list(false, None);
for item_465 in var_464 {
#[allow(unused_mut)]
let mut entry_467 = list_466.entry();
crate::query_ser::serialize_structure_crate_model_operation_result_filter(
entry_467, item_465,
)?;
}
list_466.finish();
}
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::error::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_468 = writer.prefix("StackSetName");
if let Some(var_469) = &input.stack_set_name {
scope_468.string(var_469);
}
#[allow(unused_mut)]
let mut scope_470 = writer.prefix("NextToken");
if let Some(var_471) = &input.next_token {
scope_470.string(var_471);
}
#[allow(unused_mut)]
let mut scope_472 = writer.prefix("MaxResults");
if let Some(var_473) = &input.max_results {
scope_472.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_473).into()),
);
}
#[allow(unused_mut)]
let mut scope_474 = writer.prefix("CallAs");
if let Some(var_475) = &input.call_as {
scope_474.string(var_475.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::error::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_476 = writer.prefix("NextToken");
if let Some(var_477) = &input.next_token {
scope_476.string(var_477);
}
#[allow(unused_mut)]
let mut scope_478 = writer.prefix("MaxResults");
if let Some(var_479) = &input.max_results {
scope_478.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_479).into()),
);
}
#[allow(unused_mut)]
let mut scope_480 = writer.prefix("Status");
if let Some(var_481) = &input.status {
scope_480.string(var_481.as_str());
}
#[allow(unused_mut)]
let mut scope_482 = writer.prefix("CallAs");
if let Some(var_483) = &input.call_as {
scope_482.string(var_483.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::error::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_484 = writer.prefix("Type");
if let Some(var_485) = &input.r#type {
scope_484.string(var_485.as_str());
}
#[allow(unused_mut)]
let mut scope_486 = writer.prefix("TypeName");
if let Some(var_487) = &input.type_name {
scope_486.string(var_487);
}
#[allow(unused_mut)]
let mut scope_488 = writer.prefix("TypeArn");
if let Some(var_489) = &input.type_arn {
scope_488.string(var_489);
}
#[allow(unused_mut)]
let mut scope_490 = writer.prefix("RegistrationStatusFilter");
if let Some(var_491) = &input.registration_status_filter {
scope_490.string(var_491.as_str());
}
#[allow(unused_mut)]
let mut scope_492 = writer.prefix("MaxResults");
if let Some(var_493) = &input.max_results {
scope_492.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_493).into()),
);
}
#[allow(unused_mut)]
let mut scope_494 = writer.prefix("NextToken");
if let Some(var_495) = &input.next_token {
scope_494.string(var_495);
}
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::error::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_496 = writer.prefix("Visibility");
if let Some(var_497) = &input.visibility {
scope_496.string(var_497.as_str());
}
#[allow(unused_mut)]
let mut scope_498 = writer.prefix("ProvisioningType");
if let Some(var_499) = &input.provisioning_type {
scope_498.string(var_499.as_str());
}
#[allow(unused_mut)]
let mut scope_500 = writer.prefix("DeprecatedStatus");
if let Some(var_501) = &input.deprecated_status {
scope_500.string(var_501.as_str());
}
#[allow(unused_mut)]
let mut scope_502 = writer.prefix("Type");
if let Some(var_503) = &input.r#type {
scope_502.string(var_503.as_str());
}
#[allow(unused_mut)]
let mut scope_504 = writer.prefix("Filters");
if let Some(var_505) = &input.filters {
crate::query_ser::serialize_structure_crate_model_type_filters(scope_504, var_505)?;
}
#[allow(unused_mut)]
let mut scope_506 = writer.prefix("MaxResults");
if let Some(var_507) = &input.max_results {
scope_506.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_507).into()),
);
}
#[allow(unused_mut)]
let mut scope_508 = writer.prefix("NextToken");
if let Some(var_509) = &input.next_token {
scope_508.string(var_509);
}
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::error::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_510 = writer.prefix("Type");
if let Some(var_511) = &input.r#type {
scope_510.string(var_511.as_str());
}
#[allow(unused_mut)]
let mut scope_512 = writer.prefix("TypeName");
if let Some(var_513) = &input.type_name {
scope_512.string(var_513);
}
#[allow(unused_mut)]
let mut scope_514 = writer.prefix("Arn");
if let Some(var_515) = &input.arn {
scope_514.string(var_515);
}
#[allow(unused_mut)]
let mut scope_516 = writer.prefix("MaxResults");
if let Some(var_517) = &input.max_results {
scope_516.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_517).into()),
);
}
#[allow(unused_mut)]
let mut scope_518 = writer.prefix("NextToken");
if let Some(var_519) = &input.next_token {
scope_518.string(var_519);
}
#[allow(unused_mut)]
let mut scope_520 = writer.prefix("DeprecatedStatus");
if let Some(var_521) = &input.deprecated_status {
scope_520.string(var_521.as_str());
}
#[allow(unused_mut)]
let mut scope_522 = writer.prefix("PublisherId");
if let Some(var_523) = &input.publisher_id {
scope_522.string(var_523);
}
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::error::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_524 = writer.prefix("Type");
if let Some(var_525) = &input.r#type {
scope_524.string(var_525.as_str());
}
#[allow(unused_mut)]
let mut scope_526 = writer.prefix("Arn");
if let Some(var_527) = &input.arn {
scope_526.string(var_527);
}
#[allow(unused_mut)]
let mut scope_528 = writer.prefix("TypeName");
if let Some(var_529) = &input.type_name {
scope_528.string(var_529);
}
#[allow(unused_mut)]
let mut scope_530 = writer.prefix("PublicVersionNumber");
if let Some(var_531) = &input.public_version_number {
scope_530.string(var_531);
}
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::error::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_532 = writer.prefix("BearerToken");
if let Some(var_533) = &input.bearer_token {
scope_532.string(var_533);
}
#[allow(unused_mut)]
let mut scope_534 = writer.prefix("OperationStatus");
if let Some(var_535) = &input.operation_status {
scope_534.string(var_535.as_str());
}
#[allow(unused_mut)]
let mut scope_536 = writer.prefix("CurrentOperationStatus");
if let Some(var_537) = &input.current_operation_status {
scope_536.string(var_537.as_str());
}
#[allow(unused_mut)]
let mut scope_538 = writer.prefix("StatusMessage");
if let Some(var_539) = &input.status_message {
scope_538.string(var_539);
}
#[allow(unused_mut)]
let mut scope_540 = writer.prefix("ErrorCode");
if let Some(var_541) = &input.error_code {
scope_540.string(var_541.as_str());
}
#[allow(unused_mut)]
let mut scope_542 = writer.prefix("ResourceModel");
if let Some(var_543) = &input.resource_model {
scope_542.string(var_543);
}
#[allow(unused_mut)]
let mut scope_544 = writer.prefix("ClientRequestToken");
if let Some(var_545) = &input.client_request_token {
scope_544.string(var_545);
}
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::error::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_546 = writer.prefix("AcceptTermsAndConditions");
if let Some(var_547) = &input.accept_terms_and_conditions {
scope_546.boolean(*var_547);
}
#[allow(unused_mut)]
let mut scope_548 = writer.prefix("ConnectionArn");
if let Some(var_549) = &input.connection_arn {
scope_548.string(var_549);
}
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::error::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_550 = writer.prefix("Type");
if let Some(var_551) = &input.r#type {
scope_550.string(var_551.as_str());
}
#[allow(unused_mut)]
let mut scope_552 = writer.prefix("TypeName");
if let Some(var_553) = &input.type_name {
scope_552.string(var_553);
}
#[allow(unused_mut)]
let mut scope_554 = writer.prefix("SchemaHandlerPackage");
if let Some(var_555) = &input.schema_handler_package {
scope_554.string(var_555);
}
#[allow(unused_mut)]
let mut scope_556 = writer.prefix("LoggingConfig");
if let Some(var_557) = &input.logging_config {
crate::query_ser::serialize_structure_crate_model_logging_config(scope_556, var_557)?;
}
#[allow(unused_mut)]
let mut scope_558 = writer.prefix("ExecutionRoleArn");
if let Some(var_559) = &input.execution_role_arn {
scope_558.string(var_559);
}
#[allow(unused_mut)]
let mut scope_560 = writer.prefix("ClientRequestToken");
if let Some(var_561) = &input.client_request_token {
scope_560.string(var_561);
}
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::error::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_562 = writer.prefix("StackName");
if let Some(var_563) = &input.stack_name {
scope_562.string(var_563);
}
#[allow(unused_mut)]
let mut scope_564 = writer.prefix("RoleARN");
if let Some(var_565) = &input.role_arn {
scope_564.string(var_565);
}
#[allow(unused_mut)]
let mut scope_566 = writer.prefix("ClientRequestToken");
if let Some(var_567) = &input.client_request_token {
scope_566.string(var_567);
}
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::error::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_568 = writer.prefix("StackName");
if let Some(var_569) = &input.stack_name {
scope_568.string(var_569);
}
#[allow(unused_mut)]
let mut scope_570 = writer.prefix("StackPolicyBody");
if let Some(var_571) = &input.stack_policy_body {
scope_570.string(var_571);
}
#[allow(unused_mut)]
let mut scope_572 = writer.prefix("StackPolicyURL");
if let Some(var_573) = &input.stack_policy_url {
scope_572.string(var_573);
}
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::error::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_574 = writer.prefix("TypeArn");
if let Some(var_575) = &input.type_arn {
scope_574.string(var_575);
}
#[allow(unused_mut)]
let mut scope_576 = writer.prefix("Configuration");
if let Some(var_577) = &input.configuration {
scope_576.string(var_577);
}
#[allow(unused_mut)]
let mut scope_578 = writer.prefix("ConfigurationAlias");
if let Some(var_579) = &input.configuration_alias {
scope_578.string(var_579);
}
#[allow(unused_mut)]
let mut scope_580 = writer.prefix("TypeName");
if let Some(var_581) = &input.type_name {
scope_580.string(var_581);
}
#[allow(unused_mut)]
let mut scope_582 = writer.prefix("Type");
if let Some(var_583) = &input.r#type {
scope_582.string(var_583.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::error::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_584 = writer.prefix("Arn");
if let Some(var_585) = &input.arn {
scope_584.string(var_585);
}
#[allow(unused_mut)]
let mut scope_586 = writer.prefix("Type");
if let Some(var_587) = &input.r#type {
scope_586.string(var_587.as_str());
}
#[allow(unused_mut)]
let mut scope_588 = writer.prefix("TypeName");
if let Some(var_589) = &input.type_name {
scope_588.string(var_589);
}
#[allow(unused_mut)]
let mut scope_590 = writer.prefix("VersionId");
if let Some(var_591) = &input.version_id {
scope_590.string(var_591);
}
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::error::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_592 = writer.prefix("StackName");
if let Some(var_593) = &input.stack_name {
scope_592.string(var_593);
}
#[allow(unused_mut)]
let mut scope_594 = writer.prefix("LogicalResourceId");
if let Some(var_595) = &input.logical_resource_id {
scope_594.string(var_595);
}
#[allow(unused_mut)]
let mut scope_596 = writer.prefix("UniqueId");
if let Some(var_597) = &input.unique_id {
scope_596.string(var_597);
}
#[allow(unused_mut)]
let mut scope_598 = writer.prefix("Status");
if let Some(var_599) = &input.status {
scope_598.string(var_599.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::error::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_600 = writer.prefix("StackSetName");
if let Some(var_601) = &input.stack_set_name {
scope_600.string(var_601);
}
#[allow(unused_mut)]
let mut scope_602 = writer.prefix("OperationId");
if let Some(var_603) = &input.operation_id {
scope_602.string(var_603);
}
#[allow(unused_mut)]
let mut scope_604 = writer.prefix("CallAs");
if let Some(var_605) = &input.call_as {
scope_604.string(var_605.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::error::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_606 = writer.prefix("Arn");
if let Some(var_607) = &input.arn {
scope_606.string(var_607);
}
#[allow(unused_mut)]
let mut scope_608 = writer.prefix("Type");
if let Some(var_609) = &input.r#type {
scope_608.string(var_609.as_str());
}
#[allow(unused_mut)]
let mut scope_610 = writer.prefix("TypeName");
if let Some(var_611) = &input.type_name {
scope_610.string(var_611);
}
#[allow(unused_mut)]
let mut scope_612 = writer.prefix("VersionId");
if let Some(var_613) = &input.version_id {
scope_612.string(var_613);
}
#[allow(unused_mut)]
let mut scope_614 = writer.prefix("LogDeliveryBucket");
if let Some(var_615) = &input.log_delivery_bucket {
scope_614.string(var_615);
}
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::error::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_616 = writer.prefix("StackName");
if let Some(var_617) = &input.stack_name {
scope_616.string(var_617);
}
#[allow(unused_mut)]
let mut scope_618 = writer.prefix("TemplateBody");
if let Some(var_619) = &input.template_body {
scope_618.string(var_619);
}
#[allow(unused_mut)]
let mut scope_620 = writer.prefix("TemplateURL");
if let Some(var_621) = &input.template_url {
scope_620.string(var_621);
}
#[allow(unused_mut)]
let mut scope_622 = writer.prefix("UsePreviousTemplate");
if let Some(var_623) = &input.use_previous_template {
scope_622.boolean(*var_623);
}
#[allow(unused_mut)]
let mut scope_624 = writer.prefix("StackPolicyDuringUpdateBody");
if let Some(var_625) = &input.stack_policy_during_update_body {
scope_624.string(var_625);
}
#[allow(unused_mut)]
let mut scope_626 = writer.prefix("StackPolicyDuringUpdateURL");
if let Some(var_627) = &input.stack_policy_during_update_url {
scope_626.string(var_627);
}
#[allow(unused_mut)]
let mut scope_628 = writer.prefix("Parameters");
if let Some(var_629) = &input.parameters {
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();
crate::query_ser::serialize_structure_crate_model_parameter(entry_632, item_630)?;
}
list_631.finish();
}
#[allow(unused_mut)]
let mut scope_633 = writer.prefix("Capabilities");
if let Some(var_634) = &input.capabilities {
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.as_str());
}
list_636.finish();
}
#[allow(unused_mut)]
let mut scope_638 = writer.prefix("ResourceTypes");
if let Some(var_639) = &input.resource_types {
let mut list_641 = scope_638.start_list(false, None);
for item_640 in var_639 {
#[allow(unused_mut)]
let mut entry_642 = list_641.entry();
entry_642.string(item_640);
}
list_641.finish();
}
#[allow(unused_mut)]
let mut scope_643 = writer.prefix("RoleARN");
if let Some(var_644) = &input.role_arn {
scope_643.string(var_644);
}
#[allow(unused_mut)]
let mut scope_645 = writer.prefix("RollbackConfiguration");
if let Some(var_646) = &input.rollback_configuration {
crate::query_ser::serialize_structure_crate_model_rollback_configuration(
scope_645, var_646,
)?;
}
#[allow(unused_mut)]
let mut scope_647 = writer.prefix("StackPolicyBody");
if let Some(var_648) = &input.stack_policy_body {
scope_647.string(var_648);
}
#[allow(unused_mut)]
let mut scope_649 = writer.prefix("StackPolicyURL");
if let Some(var_650) = &input.stack_policy_url {
scope_649.string(var_650);
}
#[allow(unused_mut)]
let mut scope_651 = writer.prefix("NotificationARNs");
if let Some(var_652) = &input.notification_ar_ns {
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();
entry_655.string(item_653);
}
list_654.finish();
}
#[allow(unused_mut)]
let mut scope_656 = writer.prefix("Tags");
if let Some(var_657) = &input.tags {
let mut list_659 = scope_656.start_list(false, None);
for item_658 in var_657 {
#[allow(unused_mut)]
let mut entry_660 = list_659.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_660, item_658)?;
}
list_659.finish();
}
#[allow(unused_mut)]
let mut scope_661 = writer.prefix("DisableRollback");
if let Some(var_662) = &input.disable_rollback {
scope_661.boolean(*var_662);
}
#[allow(unused_mut)]
let mut scope_663 = writer.prefix("ClientRequestToken");
if let Some(var_664) = &input.client_request_token {
scope_663.string(var_664);
}
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::error::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_665 = writer.prefix("StackSetName");
if let Some(var_666) = &input.stack_set_name {
scope_665.string(var_666);
}
#[allow(unused_mut)]
let mut scope_667 = writer.prefix("Accounts");
if let Some(var_668) = &input.accounts {
let mut list_670 = scope_667.start_list(false, None);
for item_669 in var_668 {
#[allow(unused_mut)]
let mut entry_671 = list_670.entry();
entry_671.string(item_669);
}
list_670.finish();
}
#[allow(unused_mut)]
let mut scope_672 = writer.prefix("DeploymentTargets");
if let Some(var_673) = &input.deployment_targets {
crate::query_ser::serialize_structure_crate_model_deployment_targets(scope_672, var_673)?;
}
#[allow(unused_mut)]
let mut scope_674 = writer.prefix("Regions");
if let Some(var_675) = &input.regions {
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();
entry_678.string(item_676);
}
list_677.finish();
}
#[allow(unused_mut)]
let mut scope_679 = writer.prefix("ParameterOverrides");
if let Some(var_680) = &input.parameter_overrides {
let mut list_682 = scope_679.start_list(false, None);
for item_681 in var_680 {
#[allow(unused_mut)]
let mut entry_683 = list_682.entry();
crate::query_ser::serialize_structure_crate_model_parameter(entry_683, item_681)?;
}
list_682.finish();
}
#[allow(unused_mut)]
let mut scope_684 = writer.prefix("OperationPreferences");
if let Some(var_685) = &input.operation_preferences {
crate::query_ser::serialize_structure_crate_model_stack_set_operation_preferences(
scope_684, var_685,
)?;
}
#[allow(unused_mut)]
let mut scope_686 = writer.prefix("OperationId");
if let Some(var_687) = &input.operation_id {
scope_686.string(var_687);
}
#[allow(unused_mut)]
let mut scope_688 = writer.prefix("CallAs");
if let Some(var_689) = &input.call_as {
scope_688.string(var_689.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::error::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_690 = writer.prefix("StackSetName");
if let Some(var_691) = &input.stack_set_name {
scope_690.string(var_691);
}
#[allow(unused_mut)]
let mut scope_692 = writer.prefix("Description");
if let Some(var_693) = &input.description {
scope_692.string(var_693);
}
#[allow(unused_mut)]
let mut scope_694 = writer.prefix("TemplateBody");
if let Some(var_695) = &input.template_body {
scope_694.string(var_695);
}
#[allow(unused_mut)]
let mut scope_696 = writer.prefix("TemplateURL");
if let Some(var_697) = &input.template_url {
scope_696.string(var_697);
}
#[allow(unused_mut)]
let mut scope_698 = writer.prefix("UsePreviousTemplate");
if let Some(var_699) = &input.use_previous_template {
scope_698.boolean(*var_699);
}
#[allow(unused_mut)]
let mut scope_700 = writer.prefix("Parameters");
if let Some(var_701) = &input.parameters {
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();
crate::query_ser::serialize_structure_crate_model_parameter(entry_704, item_702)?;
}
list_703.finish();
}
#[allow(unused_mut)]
let mut scope_705 = writer.prefix("Capabilities");
if let Some(var_706) = &input.capabilities {
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();
entry_709.string(item_707.as_str());
}
list_708.finish();
}
#[allow(unused_mut)]
let mut scope_710 = writer.prefix("Tags");
if let Some(var_711) = &input.tags {
let mut list_713 = scope_710.start_list(false, None);
for item_712 in var_711 {
#[allow(unused_mut)]
let mut entry_714 = list_713.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_714, item_712)?;
}
list_713.finish();
}
#[allow(unused_mut)]
let mut scope_715 = writer.prefix("OperationPreferences");
if let Some(var_716) = &input.operation_preferences {
crate::query_ser::serialize_structure_crate_model_stack_set_operation_preferences(
scope_715, var_716,
)?;
}
#[allow(unused_mut)]
let mut scope_717 = writer.prefix("AdministrationRoleARN");
if let Some(var_718) = &input.administration_role_arn {
scope_717.string(var_718);
}
#[allow(unused_mut)]
let mut scope_719 = writer.prefix("ExecutionRoleName");
if let Some(var_720) = &input.execution_role_name {
scope_719.string(var_720);
}
#[allow(unused_mut)]
let mut scope_721 = writer.prefix("DeploymentTargets");
if let Some(var_722) = &input.deployment_targets {
crate::query_ser::serialize_structure_crate_model_deployment_targets(scope_721, var_722)?;
}
#[allow(unused_mut)]
let mut scope_723 = writer.prefix("PermissionModel");
if let Some(var_724) = &input.permission_model {
scope_723.string(var_724.as_str());
}
#[allow(unused_mut)]
let mut scope_725 = writer.prefix("AutoDeployment");
if let Some(var_726) = &input.auto_deployment {
crate::query_ser::serialize_structure_crate_model_auto_deployment(scope_725, var_726)?;
}
#[allow(unused_mut)]
let mut scope_727 = writer.prefix("OperationId");
if let Some(var_728) = &input.operation_id {
scope_727.string(var_728);
}
#[allow(unused_mut)]
let mut scope_729 = writer.prefix("Accounts");
if let Some(var_730) = &input.accounts {
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("Regions");
if let Some(var_735) = &input.regions {
let mut list_737 = scope_734.start_list(false, None);
for item_736 in var_735 {
#[allow(unused_mut)]
let mut entry_738 = list_737.entry();
entry_738.string(item_736);
}
list_737.finish();
}
#[allow(unused_mut)]
let mut scope_739 = writer.prefix("CallAs");
if let Some(var_740) = &input.call_as {
scope_739.string(var_740.as_str());
}
#[allow(unused_mut)]
let mut scope_741 = writer.prefix("ManagedExecution");
if let Some(var_742) = &input.managed_execution {
crate::query_ser::serialize_structure_crate_model_managed_execution(scope_741, var_742)?;
}
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::error::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_743 = writer.prefix("EnableTerminationProtection");
if let Some(var_744) = &input.enable_termination_protection {
scope_743.boolean(*var_744);
}
#[allow(unused_mut)]
let mut scope_745 = writer.prefix("StackName");
if let Some(var_746) = &input.stack_name {
scope_745.string(var_746);
}
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::error::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_747 = writer.prefix("TemplateBody");
if let Some(var_748) = &input.template_body {
scope_747.string(var_748);
}
#[allow(unused_mut)]
let mut scope_749 = writer.prefix("TemplateURL");
if let Some(var_750) = &input.template_url {
scope_749.string(var_750);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}