Enum aws_sdk_appstream::model::AuthenticationType

#[non_exhaustive]
pub enum AuthenticationType {
    Api,
    Saml,
    Userpool,
    Unknown(UnknownVariantValue),
}

When writing a match expression against AuthenticationType, 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 authenticationtype = unimplemented!();
match authenticationtype {
    AuthenticationType::Api => { /* ... */ },
    AuthenticationType::Saml => { /* ... */ },
    AuthenticationType::Userpool => { /* ... */ },
    other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
    _ => { /* ... */ },
}

The above code demonstrates that when authenticationtype represents NewFeature, the execution path will lead to the second last match arm, even though the enum does not contain a variant AuthenticationType::NewFeature in the current version of SDK. The reason is that the variable other, created by the @ operator, is bound to AuthenticationType::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 AuthenticationType::NewFeature is defined. Specifically, when authenticationtype represents NewFeature, the execution path will hit the second last match arm as before by virtue of calling as_str on AuthenticationType::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.

Api

Saml

Userpool

Unknown(UnknownVariantValue)

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

Implementations

impl AuthenticationType

pub fn as_str(&self) -> &str

Returns the &str value of the enum member.

Examples found in repository

src/model.rs (line 5997)

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

src/json_ser.rs (line 651)

pub fn serialize_structure_crate_input_create_user_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateUserInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_159) = &input.user_name {
        object.key("UserName").string(var_159.as_str());
    }
    if let Some(var_160) = &input.message_action {
        object.key("MessageAction").string(var_160.as_str());
    }
    if let Some(var_161) = &input.first_name {
        object.key("FirstName").string(var_161.as_str());
    }
    if let Some(var_162) = &input.last_name {
        object.key("LastName").string(var_162.as_str());
    }
    if let Some(var_163) = &input.authentication_type {
        object.key("AuthenticationType").string(var_163.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_app_block_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteAppBlockInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_164) = &input.name {
        object.key("Name").string(var_164.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_application_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteApplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_165) = &input.name {
        object.key("Name").string(var_165.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_directory_config_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteDirectoryConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_166) = &input.directory_name {
        object.key("DirectoryName").string(var_166.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_entitlement_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteEntitlementInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_167) = &input.name {
        object.key("Name").string(var_167.as_str());
    }
    if let Some(var_168) = &input.stack_name {
        object.key("StackName").string(var_168.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_fleet_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteFleetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_169) = &input.name {
        object.key("Name").string(var_169.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_image_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteImageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_170) = &input.name {
        object.key("Name").string(var_170.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_image_builder_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteImageBuilderInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_171) = &input.name {
        object.key("Name").string(var_171.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_image_permissions_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteImagePermissionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_172) = &input.name {
        object.key("Name").string(var_172.as_str());
    }
    if let Some(var_173) = &input.shared_account_id {
        object.key("SharedAccountId").string(var_173.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_stack_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteStackInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_174) = &input.name {
        object.key("Name").string(var_174.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_user_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteUserInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_175) = &input.user_name {
        object.key("UserName").string(var_175.as_str());
    }
    if let Some(var_176) = &input.authentication_type {
        object.key("AuthenticationType").string(var_176.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_app_blocks_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeAppBlocksInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_177) = &input.arns {
        let mut array_178 = object.key("Arns").start_array();
        for item_179 in var_177 {
            {
                array_178.value().string(item_179.as_str());
            }
        }
        array_178.finish();
    }
    if let Some(var_180) = &input.next_token {
        object.key("NextToken").string(var_180.as_str());
    }
    if let Some(var_181) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_181).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_application_fleet_associations_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeApplicationFleetAssociationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_182) = &input.fleet_name {
        object.key("FleetName").string(var_182.as_str());
    }
    if let Some(var_183) = &input.application_arn {
        object.key("ApplicationArn").string(var_183.as_str());
    }
    if let Some(var_184) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_184).into()),
        );
    }
    if let Some(var_185) = &input.next_token {
        object.key("NextToken").string(var_185.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_applications_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeApplicationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_186) = &input.arns {
        let mut array_187 = object.key("Arns").start_array();
        for item_188 in var_186 {
            {
                array_187.value().string(item_188.as_str());
            }
        }
        array_187.finish();
    }
    if let Some(var_189) = &input.next_token {
        object.key("NextToken").string(var_189.as_str());
    }
    if let Some(var_190) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_190).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_directory_configs_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeDirectoryConfigsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_191) = &input.directory_names {
        let mut array_192 = object.key("DirectoryNames").start_array();
        for item_193 in var_191 {
            {
                array_192.value().string(item_193.as_str());
            }
        }
        array_192.finish();
    }
    if let Some(var_194) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_194).into()),
        );
    }
    if let Some(var_195) = &input.next_token {
        object.key("NextToken").string(var_195.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_entitlements_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeEntitlementsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_196) = &input.name {
        object.key("Name").string(var_196.as_str());
    }
    if let Some(var_197) = &input.stack_name {
        object.key("StackName").string(var_197.as_str());
    }
    if let Some(var_198) = &input.next_token {
        object.key("NextToken").string(var_198.as_str());
    }
    if let Some(var_199) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_199).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_fleets_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeFleetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_200) = &input.names {
        let mut array_201 = object.key("Names").start_array();
        for item_202 in var_200 {
            {
                array_201.value().string(item_202.as_str());
            }
        }
        array_201.finish();
    }
    if let Some(var_203) = &input.next_token {
        object.key("NextToken").string(var_203.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_image_builders_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeImageBuildersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_204) = &input.names {
        let mut array_205 = object.key("Names").start_array();
        for item_206 in var_204 {
            {
                array_205.value().string(item_206.as_str());
            }
        }
        array_205.finish();
    }
    if let Some(var_207) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_207).into()),
        );
    }
    if let Some(var_208) = &input.next_token {
        object.key("NextToken").string(var_208.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_image_permissions_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeImagePermissionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_209) = &input.name {
        object.key("Name").string(var_209.as_str());
    }
    if let Some(var_210) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_210).into()),
        );
    }
    if let Some(var_211) = &input.shared_aws_account_ids {
        let mut array_212 = object.key("SharedAwsAccountIds").start_array();
        for item_213 in var_211 {
            {
                array_212.value().string(item_213.as_str());
            }
        }
        array_212.finish();
    }
    if let Some(var_214) = &input.next_token {
        object.key("NextToken").string(var_214.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_images_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeImagesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_215) = &input.names {
        let mut array_216 = object.key("Names").start_array();
        for item_217 in var_215 {
            {
                array_216.value().string(item_217.as_str());
            }
        }
        array_216.finish();
    }
    if let Some(var_218) = &input.arns {
        let mut array_219 = object.key("Arns").start_array();
        for item_220 in var_218 {
            {
                array_219.value().string(item_220.as_str());
            }
        }
        array_219.finish();
    }
    if let Some(var_221) = &input.r#type {
        object.key("Type").string(var_221.as_str());
    }
    if let Some(var_222) = &input.next_token {
        object.key("NextToken").string(var_222.as_str());
    }
    if let Some(var_223) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_223).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_sessions_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeSessionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_224) = &input.stack_name {
        object.key("StackName").string(var_224.as_str());
    }
    if let Some(var_225) = &input.fleet_name {
        object.key("FleetName").string(var_225.as_str());
    }
    if let Some(var_226) = &input.user_id {
        object.key("UserId").string(var_226.as_str());
    }
    if let Some(var_227) = &input.next_token {
        object.key("NextToken").string(var_227.as_str());
    }
    if let Some(var_228) = &input.limit {
        object.key("Limit").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_228).into()),
        );
    }
    if let Some(var_229) = &input.authentication_type {
        object.key("AuthenticationType").string(var_229.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_stacks_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeStacksInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_230) = &input.names {
        let mut array_231 = object.key("Names").start_array();
        for item_232 in var_230 {
            {
                array_231.value().string(item_232.as_str());
            }
        }
        array_231.finish();
    }
    if let Some(var_233) = &input.next_token {
        object.key("NextToken").string(var_233.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_usage_report_subscriptions_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeUsageReportSubscriptionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_234) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_234).into()),
        );
    }
    if let Some(var_235) = &input.next_token {
        object.key("NextToken").string(var_235.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_users_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeUsersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_236) = &input.authentication_type {
        object.key("AuthenticationType").string(var_236.as_str());
    }
    if let Some(var_237) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_237).into()),
        );
    }
    if let Some(var_238) = &input.next_token {
        object.key("NextToken").string(var_238.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_user_stack_associations_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeUserStackAssociationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_239) = &input.stack_name {
        object.key("StackName").string(var_239.as_str());
    }
    if let Some(var_240) = &input.user_name {
        object.key("UserName").string(var_240.as_str());
    }
    if let Some(var_241) = &input.authentication_type {
        object.key("AuthenticationType").string(var_241.as_str());
    }
    if let Some(var_242) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_242).into()),
        );
    }
    if let Some(var_243) = &input.next_token {
        object.key("NextToken").string(var_243.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_disable_user_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DisableUserInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_244) = &input.user_name {
        object.key("UserName").string(var_244.as_str());
    }
    if let Some(var_245) = &input.authentication_type {
        object.key("AuthenticationType").string(var_245.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_disassociate_application_fleet_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DisassociateApplicationFleetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_246) = &input.fleet_name {
        object.key("FleetName").string(var_246.as_str());
    }
    if let Some(var_247) = &input.application_arn {
        object.key("ApplicationArn").string(var_247.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_disassociate_application_from_entitlement_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DisassociateApplicationFromEntitlementInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_248) = &input.stack_name {
        object.key("StackName").string(var_248.as_str());
    }
    if let Some(var_249) = &input.entitlement_name {
        object.key("EntitlementName").string(var_249.as_str());
    }
    if let Some(var_250) = &input.application_identifier {
        object.key("ApplicationIdentifier").string(var_250.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_disassociate_fleet_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DisassociateFleetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_251) = &input.fleet_name {
        object.key("FleetName").string(var_251.as_str());
    }
    if let Some(var_252) = &input.stack_name {
        object.key("StackName").string(var_252.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_enable_user_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::EnableUserInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_253) = &input.user_name {
        object.key("UserName").string(var_253.as_str());
    }
    if let Some(var_254) = &input.authentication_type {
        object.key("AuthenticationType").string(var_254.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_expire_session_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ExpireSessionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_255) = &input.session_id {
        object.key("SessionId").string(var_255.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_associated_fleets_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListAssociatedFleetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_256) = &input.stack_name {
        object.key("StackName").string(var_256.as_str());
    }
    if let Some(var_257) = &input.next_token {
        object.key("NextToken").string(var_257.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_associated_stacks_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListAssociatedStacksInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_258) = &input.fleet_name {
        object.key("FleetName").string(var_258.as_str());
    }
    if let Some(var_259) = &input.next_token {
        object.key("NextToken").string(var_259.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_entitled_applications_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListEntitledApplicationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_260) = &input.stack_name {
        object.key("StackName").string(var_260.as_str());
    }
    if let Some(var_261) = &input.entitlement_name {
        object.key("EntitlementName").string(var_261.as_str());
    }
    if let Some(var_262) = &input.next_token {
        object.key("NextToken").string(var_262.as_str());
    }
    if let Some(var_263) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_263).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_tags_for_resource_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListTagsForResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_264) = &input.resource_arn {
        object.key("ResourceArn").string(var_264.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_start_fleet_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::StartFleetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_265) = &input.name {
        object.key("Name").string(var_265.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_start_image_builder_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::StartImageBuilderInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_266) = &input.name {
        object.key("Name").string(var_266.as_str());
    }
    if let Some(var_267) = &input.appstream_agent_version {
        object.key("AppstreamAgentVersion").string(var_267.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_stop_fleet_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::StopFleetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_268) = &input.name {
        object.key("Name").string(var_268.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_stop_image_builder_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::StopImageBuilderInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_269) = &input.name {
        object.key("Name").string(var_269.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_tag_resource_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_270) = &input.resource_arn {
        object.key("ResourceArn").string(var_270.as_str());
    }
    if let Some(var_271) = &input.tags {
        #[allow(unused_mut)]
        let mut object_272 = object.key("Tags").start_object();
        for (key_273, value_274) in var_271 {
            {
                object_272.key(key_273.as_str()).string(value_274.as_str());
            }
        }
        object_272.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_untag_resource_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UntagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_275) = &input.resource_arn {
        object.key("ResourceArn").string(var_275.as_str());
    }
    if let Some(var_276) = &input.tag_keys {
        let mut array_277 = object.key("TagKeys").start_array();
        for item_278 in var_276 {
            {
                array_277.value().string(item_278.as_str());
            }
        }
        array_277.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_application_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateApplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_279) = &input.name {
        object.key("Name").string(var_279.as_str());
    }
    if let Some(var_280) = &input.display_name {
        object.key("DisplayName").string(var_280.as_str());
    }
    if let Some(var_281) = &input.description {
        object.key("Description").string(var_281.as_str());
    }
    if let Some(var_282) = &input.icon_s3_location {
        #[allow(unused_mut)]
        let mut object_283 = object.key("IconS3Location").start_object();
        crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_283, var_282)?;
        object_283.finish();
    }
    if let Some(var_284) = &input.launch_path {
        object.key("LaunchPath").string(var_284.as_str());
    }
    if let Some(var_285) = &input.working_directory {
        object.key("WorkingDirectory").string(var_285.as_str());
    }
    if let Some(var_286) = &input.launch_parameters {
        object.key("LaunchParameters").string(var_286.as_str());
    }
    if let Some(var_287) = &input.app_block_arn {
        object.key("AppBlockArn").string(var_287.as_str());
    }
    if let Some(var_288) = &input.attributes_to_delete {
        let mut array_289 = object.key("AttributesToDelete").start_array();
        for item_290 in var_288 {
            {
                array_289.value().string(item_290.as_str());
            }
        }
        array_289.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_directory_config_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateDirectoryConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_291) = &input.directory_name {
        object.key("DirectoryName").string(var_291.as_str());
    }
    if let Some(var_292) = &input.organizational_unit_distinguished_names {
        let mut array_293 = object
            .key("OrganizationalUnitDistinguishedNames")
            .start_array();
        for item_294 in var_292 {
            {
                array_293.value().string(item_294.as_str());
            }
        }
        array_293.finish();
    }
    if let Some(var_295) = &input.service_account_credentials {
        #[allow(unused_mut)]
        let mut object_296 = object.key("ServiceAccountCredentials").start_object();
        crate::json_ser::serialize_structure_crate_model_service_account_credentials(
            &mut object_296,
            var_295,
        )?;
        object_296.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_entitlement_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateEntitlementInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_297) = &input.name {
        object.key("Name").string(var_297.as_str());
    }
    if let Some(var_298) = &input.stack_name {
        object.key("StackName").string(var_298.as_str());
    }
    if let Some(var_299) = &input.description {
        object.key("Description").string(var_299.as_str());
    }
    if let Some(var_300) = &input.app_visibility {
        object.key("AppVisibility").string(var_300.as_str());
    }
    if let Some(var_301) = &input.attributes {
        let mut array_302 = object.key("Attributes").start_array();
        for item_303 in var_301 {
            {
                #[allow(unused_mut)]
                let mut object_304 = array_302.value().start_object();
                crate::json_ser::serialize_structure_crate_model_entitlement_attribute(
                    &mut object_304,
                    item_303,
                )?;
                object_304.finish();
            }
        }
        array_302.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_fleet_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateFleetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_305) = &input.image_name {
        object.key("ImageName").string(var_305.as_str());
    }
    if let Some(var_306) = &input.image_arn {
        object.key("ImageArn").string(var_306.as_str());
    }
    if let Some(var_307) = &input.name {
        object.key("Name").string(var_307.as_str());
    }
    if let Some(var_308) = &input.instance_type {
        object.key("InstanceType").string(var_308.as_str());
    }
    if let Some(var_309) = &input.compute_capacity {
        #[allow(unused_mut)]
        let mut object_310 = object.key("ComputeCapacity").start_object();
        crate::json_ser::serialize_structure_crate_model_compute_capacity(
            &mut object_310,
            var_309,
        )?;
        object_310.finish();
    }
    if let Some(var_311) = &input.vpc_config {
        #[allow(unused_mut)]
        let mut object_312 = object.key("VpcConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_312, var_311)?;
        object_312.finish();
    }
    if let Some(var_313) = &input.max_user_duration_in_seconds {
        object.key("MaxUserDurationInSeconds").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_313).into()),
        );
    }
    if let Some(var_314) = &input.disconnect_timeout_in_seconds {
        object.key("DisconnectTimeoutInSeconds").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_314).into()),
        );
    }
    if input.delete_vpc_config {
        object
            .key("DeleteVpcConfig")
            .boolean(input.delete_vpc_config);
    }
    if let Some(var_315) = &input.description {
        object.key("Description").string(var_315.as_str());
    }
    if let Some(var_316) = &input.display_name {
        object.key("DisplayName").string(var_316.as_str());
    }
    if let Some(var_317) = &input.enable_default_internet_access {
        object.key("EnableDefaultInternetAccess").boolean(*var_317);
    }
    if let Some(var_318) = &input.domain_join_info {
        #[allow(unused_mut)]
        let mut object_319 = object.key("DomainJoinInfo").start_object();
        crate::json_ser::serialize_structure_crate_model_domain_join_info(
            &mut object_319,
            var_318,
        )?;
        object_319.finish();
    }
    if let Some(var_320) = &input.idle_disconnect_timeout_in_seconds {
        object.key("IdleDisconnectTimeoutInSeconds").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_320).into()),
        );
    }
    if let Some(var_321) = &input.attributes_to_delete {
        let mut array_322 = object.key("AttributesToDelete").start_array();
        for item_323 in var_321 {
            {
                array_322.value().string(item_323.as_str());
            }
        }
        array_322.finish();
    }
    if let Some(var_324) = &input.iam_role_arn {
        object.key("IamRoleArn").string(var_324.as_str());
    }
    if let Some(var_325) = &input.stream_view {
        object.key("StreamView").string(var_325.as_str());
    }
    if let Some(var_326) = &input.platform {
        object.key("Platform").string(var_326.as_str());
    }
    if let Some(var_327) = &input.max_concurrent_sessions {
        object.key("MaxConcurrentSessions").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_327).into()),
        );
    }
    if let Some(var_328) = &input.usb_device_filter_strings {
        let mut array_329 = object.key("UsbDeviceFilterStrings").start_array();
        for item_330 in var_328 {
            {
                array_329.value().string(item_330.as_str());
            }
        }
        array_329.finish();
    }
    if let Some(var_331) = &input.session_script_s3_location {
        #[allow(unused_mut)]
        let mut object_332 = object.key("SessionScriptS3Location").start_object();
        crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_332, var_331)?;
        object_332.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_image_permissions_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateImagePermissionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_333) = &input.name {
        object.key("Name").string(var_333.as_str());
    }
    if let Some(var_334) = &input.shared_account_id {
        object.key("SharedAccountId").string(var_334.as_str());
    }
    if let Some(var_335) = &input.image_permissions {
        #[allow(unused_mut)]
        let mut object_336 = object.key("ImagePermissions").start_object();
        crate::json_ser::serialize_structure_crate_model_image_permissions(
            &mut object_336,
            var_335,
        )?;
        object_336.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_stack_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateStackInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_337) = &input.display_name {
        object.key("DisplayName").string(var_337.as_str());
    }
    if let Some(var_338) = &input.description {
        object.key("Description").string(var_338.as_str());
    }
    if let Some(var_339) = &input.name {
        object.key("Name").string(var_339.as_str());
    }
    if let Some(var_340) = &input.storage_connectors {
        let mut array_341 = object.key("StorageConnectors").start_array();
        for item_342 in var_340 {
            {
                #[allow(unused_mut)]
                let mut object_343 = array_341.value().start_object();
                crate::json_ser::serialize_structure_crate_model_storage_connector(
                    &mut object_343,
                    item_342,
                )?;
                object_343.finish();
            }
        }
        array_341.finish();
    }
    if input.delete_storage_connectors {
        object
            .key("DeleteStorageConnectors")
            .boolean(input.delete_storage_connectors);
    }
    if let Some(var_344) = &input.redirect_url {
        object.key("RedirectURL").string(var_344.as_str());
    }
    if let Some(var_345) = &input.feedback_url {
        object.key("FeedbackURL").string(var_345.as_str());
    }
    if let Some(var_346) = &input.attributes_to_delete {
        let mut array_347 = object.key("AttributesToDelete").start_array();
        for item_348 in var_346 {
            {
                array_347.value().string(item_348.as_str());
            }
        }
        array_347.finish();
    }
    if let Some(var_349) = &input.user_settings {
        let mut array_350 = object.key("UserSettings").start_array();
        for item_351 in var_349 {
            {
                #[allow(unused_mut)]
                let mut object_352 = array_350.value().start_object();
                crate::json_ser::serialize_structure_crate_model_user_setting(
                    &mut object_352,
                    item_351,
                )?;
                object_352.finish();
            }
        }
        array_350.finish();
    }
    if let Some(var_353) = &input.application_settings {
        #[allow(unused_mut)]
        let mut object_354 = object.key("ApplicationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_application_settings(
            &mut object_354,
            var_353,
        )?;
        object_354.finish();
    }
    if let Some(var_355) = &input.access_endpoints {
        let mut array_356 = object.key("AccessEndpoints").start_array();
        for item_357 in var_355 {
            {
                #[allow(unused_mut)]
                let mut object_358 = array_356.value().start_object();
                crate::json_ser::serialize_structure_crate_model_access_endpoint(
                    &mut object_358,
                    item_357,
                )?;
                object_358.finish();
            }
        }
        array_356.finish();
    }
    if let Some(var_359) = &input.embed_host_domains {
        let mut array_360 = object.key("EmbedHostDomains").start_array();
        for item_361 in var_359 {
            {
                array_360.value().string(item_361.as_str());
            }
        }
        array_360.finish();
    }
    if let Some(var_362) = &input.streaming_experience_settings {
        #[allow(unused_mut)]
        let mut object_363 = object.key("StreamingExperienceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_streaming_experience_settings(
            &mut object_363,
            var_362,
        )?;
        object_363.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_user_stack_association(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::UserStackAssociation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_364) = &input.stack_name {
        object.key("StackName").string(var_364.as_str());
    }
    if let Some(var_365) = &input.user_name {
        object.key("UserName").string(var_365.as_str());
    }
    if let Some(var_366) = &input.authentication_type {
        object.key("AuthenticationType").string(var_366.as_str());
    }
    if input.send_email_notification {
        object
            .key("SendEmailNotification")
            .boolean(input.send_email_notification);
    }
    Ok(())
}

pub const fn values() -> &'static [&'static str]

Returns all the &str values of the enum members.

Trait Implementations

impl AsRef<str> for AuthenticationType

fn as_ref(&self) -> &str

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

impl Clone for AuthenticationType

fn clone(&self) -> AuthenticationType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AuthenticationType

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

Formats the value using the given formatter.

impl From<&str> for AuthenticationType

fn from(s: &str) -> Self

Converts to this type from the input type.

impl FromStr for AuthenticationType

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 AuthenticationType

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 AuthenticationType

fn cmp(&self, other: &AuthenticationType) -> 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<AuthenticationType> for AuthenticationType

fn eq(&self, other: &AuthenticationType) -> 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<AuthenticationType> for AuthenticationType

fn partial_cmp(&self, other: &AuthenticationType) -> 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 AuthenticationType

impl StructuralEq for AuthenticationType

impl StructuralPartialEq for AuthenticationType