Enum aws_sdk_cloudformation::model::PermissionModels

#[non_exhaustive]
pub enum PermissionModels {
    SelfManaged,
    ServiceManaged,
    Unknown(UnknownVariantValue),
}

When writing a match expression against PermissionModels, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Here is an example of how you can make a match expression forward-compatible:

# let permissionmodels = unimplemented!();
match permissionmodels {
    PermissionModels::SelfManaged => { /* ... */ },
    PermissionModels::ServiceManaged => { /* ... */ },
    other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
    _ => { /* ... */ },
}

The above code demonstrates that when permissionmodels represents NewFeature, the execution path will lead to the second last match arm, even though the enum does not contain a variant PermissionModels::NewFeature in the current version of SDK. The reason is that the variable other, created by the @ operator, is bound to PermissionModels::Unknown(UnknownVariantValue("NewFeature".to_owned())) and calling as_str on it yields "NewFeature". This match expression is forward-compatible when executed with a newer version of SDK where the variant PermissionModels::NewFeature is defined. Specifically, when permissionmodels represents NewFeature, the execution path will hit the second last match arm as before by virtue of calling as_str on PermissionModels::NewFeature also yielding "NewFeature".

Explicitly matching on the Unknown variant should be avoided for two reasons:

• The inner data UnknownVariantValue is opaque, and no further information can be extracted.
• It might inadvertently shadow other intended match arms.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

SelfManaged

ServiceManaged

Unknown(UnknownVariantValue)

Unknown contains new variants that have been added since this code was generated.

Implementations

impl PermissionModels

pub fn as_str(&self) -> &str

Returns the &str value of the enum member.

Examples found in repository

src/model.rs (line 523)

    fn as_ref(&self) -> &str {
        self.as_str()
    }

src/operation_ser.rs (line 561)

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());
    }
    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_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::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_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::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_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::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_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::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_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::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_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::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_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::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_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::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_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::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_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::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_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::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_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::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_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::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_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::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_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::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_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::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_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::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_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::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_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 const fn values() -> &'static [&'static str]

Returns all the &str values of the enum members.

Trait Implementations

impl AsRef<str> for PermissionModels

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for PermissionModels

fn clone(&self) -> PermissionModels

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PermissionModels

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<&str> for PermissionModels

fn from(s: &str) -> Self

Converts to this type from the input type.

impl FromStr for PermissionModels

type Err = Infallible

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for PermissionModels

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for PermissionModels

fn cmp(&self, other: &PermissionModels) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<PermissionModels> for PermissionModels

fn eq(&self, other: &PermissionModels) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<PermissionModels> for PermissionModels

fn partial_cmp(&self, other: &PermissionModels) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for PermissionModels

impl StructuralEq for PermissionModels

impl StructuralPartialEq for PermissionModels