Enum aws_sdk_iot::model::AuthorizerStatus

#[non_exhaustive]
pub enum AuthorizerStatus {
    Active,
    Inactive,
    Unknown(UnknownVariantValue),
}

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

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

Active

Inactive

Unknown(UnknownVariantValue)

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

Implementations

impl AuthorizerStatus

pub fn as_str(&self) -> &str

Returns the &str value of the enum member.

Examples found in repository

src/model.rs (line 6465)

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

src/json_ser.rs (line 157)

pub fn serialize_structure_crate_input_create_authorizer_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateAuthorizerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_28) = &input.authorizer_function_arn {
        object.key("authorizerFunctionArn").string(var_28.as_str());
    }
    if let Some(var_29) = &input.enable_caching_for_http {
        object.key("enableCachingForHttp").boolean(*var_29);
    }
    if let Some(var_30) = &input.signing_disabled {
        object.key("signingDisabled").boolean(*var_30);
    }
    if let Some(var_31) = &input.status {
        object.key("status").string(var_31.as_str());
    }
    if let Some(var_32) = &input.tags {
        let mut array_33 = object.key("tags").start_array();
        for item_34 in var_32 {
            {
                #[allow(unused_mut)]
                let mut object_35 = array_33.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_35, item_34)?;
                object_35.finish();
            }
        }
        array_33.finish();
    }
    if let Some(var_36) = &input.token_key_name {
        object.key("tokenKeyName").string(var_36.as_str());
    }
    if let Some(var_37) = &input.token_signing_public_keys {
        #[allow(unused_mut)]
        let mut object_38 = object.key("tokenSigningPublicKeys").start_object();
        for (key_39, value_40) in var_37 {
            {
                object_38.key(key_39.as_str()).string(value_40.as_str());
            }
        }
        object_38.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_billing_group_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateBillingGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_41) = &input.billing_group_properties {
        #[allow(unused_mut)]
        let mut object_42 = object.key("billingGroupProperties").start_object();
        crate::json_ser::serialize_structure_crate_model_billing_group_properties(
            &mut object_42,
            var_41,
        )?;
        object_42.finish();
    }
    if let Some(var_43) = &input.tags {
        let mut array_44 = object.key("tags").start_array();
        for item_45 in var_43 {
            {
                #[allow(unused_mut)]
                let mut object_46 = array_44.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_46, item_45)?;
                object_46.finish();
            }
        }
        array_44.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_certificate_from_csr_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateCertificateFromCsrInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_47) = &input.certificate_signing_request {
        object
            .key("certificateSigningRequest")
            .string(var_47.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_custom_metric_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateCustomMetricInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_48) = &input.client_request_token {
        object.key("clientRequestToken").string(var_48.as_str());
    }
    if let Some(var_49) = &input.display_name {
        object.key("displayName").string(var_49.as_str());
    }
    if let Some(var_50) = &input.metric_type {
        object.key("metricType").string(var_50.as_str());
    }
    if let Some(var_51) = &input.tags {
        let mut array_52 = object.key("tags").start_array();
        for item_53 in var_51 {
            {
                #[allow(unused_mut)]
                let mut object_54 = array_52.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_54, item_53)?;
                object_54.finish();
            }
        }
        array_52.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_dimension_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateDimensionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_55) = &input.client_request_token {
        object.key("clientRequestToken").string(var_55.as_str());
    }
    if let Some(var_56) = &input.string_values {
        let mut array_57 = object.key("stringValues").start_array();
        for item_58 in var_56 {
            {
                array_57.value().string(item_58.as_str());
            }
        }
        array_57.finish();
    }
    if let Some(var_59) = &input.tags {
        let mut array_60 = object.key("tags").start_array();
        for item_61 in var_59 {
            {
                #[allow(unused_mut)]
                let mut object_62 = array_60.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_62, item_61)?;
                object_62.finish();
            }
        }
        array_60.finish();
    }
    if let Some(var_63) = &input.r#type {
        object.key("type").string(var_63.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_domain_configuration_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateDomainConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_64) = &input.authorizer_config {
        #[allow(unused_mut)]
        let mut object_65 = object.key("authorizerConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_authorizer_config(&mut object_65, var_64)?;
        object_65.finish();
    }
    if let Some(var_66) = &input.domain_name {
        object.key("domainName").string(var_66.as_str());
    }
    if let Some(var_67) = &input.server_certificate_arns {
        let mut array_68 = object.key("serverCertificateArns").start_array();
        for item_69 in var_67 {
            {
                array_68.value().string(item_69.as_str());
            }
        }
        array_68.finish();
    }
    if let Some(var_70) = &input.service_type {
        object.key("serviceType").string(var_70.as_str());
    }
    if let Some(var_71) = &input.tags {
        let mut array_72 = object.key("tags").start_array();
        for item_73 in var_71 {
            {
                #[allow(unused_mut)]
                let mut object_74 = array_72.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_74, item_73)?;
                object_74.finish();
            }
        }
        array_72.finish();
    }
    if let Some(var_75) = &input.validation_certificate_arn {
        object
            .key("validationCertificateArn")
            .string(var_75.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_dynamic_thing_group_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateDynamicThingGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_76) = &input.index_name {
        object.key("indexName").string(var_76.as_str());
    }
    if let Some(var_77) = &input.query_string {
        object.key("queryString").string(var_77.as_str());
    }
    if let Some(var_78) = &input.query_version {
        object.key("queryVersion").string(var_78.as_str());
    }
    if let Some(var_79) = &input.tags {
        let mut array_80 = object.key("tags").start_array();
        for item_81 in var_79 {
            {
                #[allow(unused_mut)]
                let mut object_82 = array_80.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_82, item_81)?;
                object_82.finish();
            }
        }
        array_80.finish();
    }
    if let Some(var_83) = &input.thing_group_properties {
        #[allow(unused_mut)]
        let mut object_84 = object.key("thingGroupProperties").start_object();
        crate::json_ser::serialize_structure_crate_model_thing_group_properties(
            &mut object_84,
            var_83,
        )?;
        object_84.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_fleet_metric_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateFleetMetricInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_85) = &input.aggregation_field {
        object.key("aggregationField").string(var_85.as_str());
    }
    if let Some(var_86) = &input.aggregation_type {
        #[allow(unused_mut)]
        let mut object_87 = object.key("aggregationType").start_object();
        crate::json_ser::serialize_structure_crate_model_aggregation_type(&mut object_87, var_86)?;
        object_87.finish();
    }
    if let Some(var_88) = &input.description {
        object.key("description").string(var_88.as_str());
    }
    if let Some(var_89) = &input.index_name {
        object.key("indexName").string(var_89.as_str());
    }
    if let Some(var_90) = &input.period {
        object.key("period").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_90).into()),
        );
    }
    if let Some(var_91) = &input.query_string {
        object.key("queryString").string(var_91.as_str());
    }
    if let Some(var_92) = &input.query_version {
        object.key("queryVersion").string(var_92.as_str());
    }
    if let Some(var_93) = &input.tags {
        let mut array_94 = object.key("tags").start_array();
        for item_95 in var_93 {
            {
                #[allow(unused_mut)]
                let mut object_96 = array_94.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_96, item_95)?;
                object_96.finish();
            }
        }
        array_94.finish();
    }
    if let Some(var_97) = &input.unit {
        object.key("unit").string(var_97.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_job_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_98) = &input.abort_config {
        #[allow(unused_mut)]
        let mut object_99 = object.key("abortConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_abort_config(&mut object_99, var_98)?;
        object_99.finish();
    }
    if let Some(var_100) = &input.description {
        object.key("description").string(var_100.as_str());
    }
    if let Some(var_101) = &input.document {
        object.key("document").string(var_101.as_str());
    }
    if let Some(var_102) = &input.document_parameters {
        #[allow(unused_mut)]
        let mut object_103 = object.key("documentParameters").start_object();
        for (key_104, value_105) in var_102 {
            {
                object_103.key(key_104.as_str()).string(value_105.as_str());
            }
        }
        object_103.finish();
    }
    if let Some(var_106) = &input.document_source {
        object.key("documentSource").string(var_106.as_str());
    }
    if let Some(var_107) = &input.job_executions_retry_config {
        #[allow(unused_mut)]
        let mut object_108 = object.key("jobExecutionsRetryConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_job_executions_retry_config(
            &mut object_108,
            var_107,
        )?;
        object_108.finish();
    }
    if let Some(var_109) = &input.job_executions_rollout_config {
        #[allow(unused_mut)]
        let mut object_110 = object.key("jobExecutionsRolloutConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_job_executions_rollout_config(
            &mut object_110,
            var_109,
        )?;
        object_110.finish();
    }
    if let Some(var_111) = &input.job_template_arn {
        object.key("jobTemplateArn").string(var_111.as_str());
    }
    if let Some(var_112) = &input.namespace_id {
        object.key("namespaceId").string(var_112.as_str());
    }
    if let Some(var_113) = &input.presigned_url_config {
        #[allow(unused_mut)]
        let mut object_114 = object.key("presignedUrlConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_presigned_url_config(
            &mut object_114,
            var_113,
        )?;
        object_114.finish();
    }
    if let Some(var_115) = &input.tags {
        let mut array_116 = object.key("tags").start_array();
        for item_117 in var_115 {
            {
                #[allow(unused_mut)]
                let mut object_118 = array_116.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_118, item_117)?;
                object_118.finish();
            }
        }
        array_116.finish();
    }
    if let Some(var_119) = &input.target_selection {
        object.key("targetSelection").string(var_119.as_str());
    }
    if let Some(var_120) = &input.targets {
        let mut array_121 = object.key("targets").start_array();
        for item_122 in var_120 {
            {
                array_121.value().string(item_122.as_str());
            }
        }
        array_121.finish();
    }
    if let Some(var_123) = &input.timeout_config {
        #[allow(unused_mut)]
        let mut object_124 = object.key("timeoutConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_timeout_config(&mut object_124, var_123)?;
        object_124.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_job_template_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateJobTemplateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_125) = &input.abort_config {
        #[allow(unused_mut)]
        let mut object_126 = object.key("abortConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_abort_config(&mut object_126, var_125)?;
        object_126.finish();
    }
    if let Some(var_127) = &input.description {
        object.key("description").string(var_127.as_str());
    }
    if let Some(var_128) = &input.document {
        object.key("document").string(var_128.as_str());
    }
    if let Some(var_129) = &input.document_source {
        object.key("documentSource").string(var_129.as_str());
    }
    if let Some(var_130) = &input.job_arn {
        object.key("jobArn").string(var_130.as_str());
    }
    if let Some(var_131) = &input.job_executions_retry_config {
        #[allow(unused_mut)]
        let mut object_132 = object.key("jobExecutionsRetryConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_job_executions_retry_config(
            &mut object_132,
            var_131,
        )?;
        object_132.finish();
    }
    if let Some(var_133) = &input.job_executions_rollout_config {
        #[allow(unused_mut)]
        let mut object_134 = object.key("jobExecutionsRolloutConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_job_executions_rollout_config(
            &mut object_134,
            var_133,
        )?;
        object_134.finish();
    }
    if let Some(var_135) = &input.presigned_url_config {
        #[allow(unused_mut)]
        let mut object_136 = object.key("presignedUrlConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_presigned_url_config(
            &mut object_136,
            var_135,
        )?;
        object_136.finish();
    }
    if let Some(var_137) = &input.tags {
        let mut array_138 = object.key("tags").start_array();
        for item_139 in var_137 {
            {
                #[allow(unused_mut)]
                let mut object_140 = array_138.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_140, item_139)?;
                object_140.finish();
            }
        }
        array_138.finish();
    }
    if let Some(var_141) = &input.timeout_config {
        #[allow(unused_mut)]
        let mut object_142 = object.key("timeoutConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_timeout_config(&mut object_142, var_141)?;
        object_142.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_mitigation_action_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateMitigationActionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_143) = &input.action_params {
        #[allow(unused_mut)]
        let mut object_144 = object.key("actionParams").start_object();
        crate::json_ser::serialize_structure_crate_model_mitigation_action_params(
            &mut object_144,
            var_143,
        )?;
        object_144.finish();
    }
    if let Some(var_145) = &input.role_arn {
        object.key("roleArn").string(var_145.as_str());
    }
    if let Some(var_146) = &input.tags {
        let mut array_147 = object.key("tags").start_array();
        for item_148 in var_146 {
            {
                #[allow(unused_mut)]
                let mut object_149 = array_147.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_149, item_148)?;
                object_149.finish();
            }
        }
        array_147.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_ota_update_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateOtaUpdateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_150) = &input.additional_parameters {
        #[allow(unused_mut)]
        let mut object_151 = object.key("additionalParameters").start_object();
        for (key_152, value_153) in var_150 {
            {
                object_151.key(key_152.as_str()).string(value_153.as_str());
            }
        }
        object_151.finish();
    }
    if let Some(var_154) = &input.aws_job_abort_config {
        #[allow(unused_mut)]
        let mut object_155 = object.key("awsJobAbortConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_job_abort_config(
            &mut object_155,
            var_154,
        )?;
        object_155.finish();
    }
    if let Some(var_156) = &input.aws_job_executions_rollout_config {
        #[allow(unused_mut)]
        let mut object_157 = object.key("awsJobExecutionsRolloutConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_job_executions_rollout_config(
            &mut object_157,
            var_156,
        )?;
        object_157.finish();
    }
    if let Some(var_158) = &input.aws_job_presigned_url_config {
        #[allow(unused_mut)]
        let mut object_159 = object.key("awsJobPresignedUrlConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_job_presigned_url_config(
            &mut object_159,
            var_158,
        )?;
        object_159.finish();
    }
    if let Some(var_160) = &input.aws_job_timeout_config {
        #[allow(unused_mut)]
        let mut object_161 = object.key("awsJobTimeoutConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_job_timeout_config(
            &mut object_161,
            var_160,
        )?;
        object_161.finish();
    }
    if let Some(var_162) = &input.description {
        object.key("description").string(var_162.as_str());
    }
    if let Some(var_163) = &input.files {
        let mut array_164 = object.key("files").start_array();
        for item_165 in var_163 {
            {
                #[allow(unused_mut)]
                let mut object_166 = array_164.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ota_update_file(
                    &mut object_166,
                    item_165,
                )?;
                object_166.finish();
            }
        }
        array_164.finish();
    }
    if let Some(var_167) = &input.protocols {
        let mut array_168 = object.key("protocols").start_array();
        for item_169 in var_167 {
            {
                array_168.value().string(item_169.as_str());
            }
        }
        array_168.finish();
    }
    if let Some(var_170) = &input.role_arn {
        object.key("roleArn").string(var_170.as_str());
    }
    if let Some(var_171) = &input.tags {
        let mut array_172 = object.key("tags").start_array();
        for item_173 in var_171 {
            {
                #[allow(unused_mut)]
                let mut object_174 = array_172.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_174, item_173)?;
                object_174.finish();
            }
        }
        array_172.finish();
    }
    if let Some(var_175) = &input.target_selection {
        object.key("targetSelection").string(var_175.as_str());
    }
    if let Some(var_176) = &input.targets {
        let mut array_177 = object.key("targets").start_array();
        for item_178 in var_176 {
            {
                array_177.value().string(item_178.as_str());
            }
        }
        array_177.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_policy_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreatePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_179) = &input.policy_document {
        object.key("policyDocument").string(var_179.as_str());
    }
    if let Some(var_180) = &input.tags {
        let mut array_181 = object.key("tags").start_array();
        for item_182 in var_180 {
            {
                #[allow(unused_mut)]
                let mut object_183 = array_181.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_183, item_182)?;
                object_183.finish();
            }
        }
        array_181.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_policy_version_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreatePolicyVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_184) = &input.policy_document {
        object.key("policyDocument").string(var_184.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_provisioning_template_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateProvisioningTemplateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_185) = &input.description {
        object.key("description").string(var_185.as_str());
    }
    if input.enabled {
        object.key("enabled").boolean(input.enabled);
    }
    if let Some(var_186) = &input.pre_provisioning_hook {
        #[allow(unused_mut)]
        let mut object_187 = object.key("preProvisioningHook").start_object();
        crate::json_ser::serialize_structure_crate_model_provisioning_hook(
            &mut object_187,
            var_186,
        )?;
        object_187.finish();
    }
    if let Some(var_188) = &input.provisioning_role_arn {
        object.key("provisioningRoleArn").string(var_188.as_str());
    }
    if let Some(var_189) = &input.tags {
        let mut array_190 = object.key("tags").start_array();
        for item_191 in var_189 {
            {
                #[allow(unused_mut)]
                let mut object_192 = array_190.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_192, item_191)?;
                object_192.finish();
            }
        }
        array_190.finish();
    }
    if let Some(var_193) = &input.template_body {
        object.key("templateBody").string(var_193.as_str());
    }
    if let Some(var_194) = &input.template_name {
        object.key("templateName").string(var_194.as_str());
    }
    if let Some(var_195) = &input.r#type {
        object.key("type").string(var_195.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_provisioning_template_version_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateProvisioningTemplateVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_196) = &input.template_body {
        object.key("templateBody").string(var_196.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_role_alias_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateRoleAliasInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_197) = &input.credential_duration_seconds {
        object.key("credentialDurationSeconds").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_197).into()),
        );
    }
    if let Some(var_198) = &input.role_arn {
        object.key("roleArn").string(var_198.as_str());
    }
    if let Some(var_199) = &input.tags {
        let mut array_200 = object.key("tags").start_array();
        for item_201 in var_199 {
            {
                #[allow(unused_mut)]
                let mut object_202 = array_200.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_202, item_201)?;
                object_202.finish();
            }
        }
        array_200.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_scheduled_audit_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateScheduledAuditInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_203) = &input.day_of_month {
        object.key("dayOfMonth").string(var_203.as_str());
    }
    if let Some(var_204) = &input.day_of_week {
        object.key("dayOfWeek").string(var_204.as_str());
    }
    if let Some(var_205) = &input.frequency {
        object.key("frequency").string(var_205.as_str());
    }
    if let Some(var_206) = &input.tags {
        let mut array_207 = object.key("tags").start_array();
        for item_208 in var_206 {
            {
                #[allow(unused_mut)]
                let mut object_209 = array_207.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_209, item_208)?;
                object_209.finish();
            }
        }
        array_207.finish();
    }
    if let Some(var_210) = &input.target_check_names {
        let mut array_211 = object.key("targetCheckNames").start_array();
        for item_212 in var_210 {
            {
                array_211.value().string(item_212.as_str());
            }
        }
        array_211.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_security_profile_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateSecurityProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_213) = &input.additional_metrics_to_retain {
        let mut array_214 = object.key("additionalMetricsToRetain").start_array();
        for item_215 in var_213 {
            {
                array_214.value().string(item_215.as_str());
            }
        }
        array_214.finish();
    }
    if let Some(var_216) = &input.additional_metrics_to_retain_v2 {
        let mut array_217 = object.key("additionalMetricsToRetainV2").start_array();
        for item_218 in var_216 {
            {
                #[allow(unused_mut)]
                let mut object_219 = array_217.value().start_object();
                crate::json_ser::serialize_structure_crate_model_metric_to_retain(
                    &mut object_219,
                    item_218,
                )?;
                object_219.finish();
            }
        }
        array_217.finish();
    }
    if let Some(var_220) = &input.alert_targets {
        #[allow(unused_mut)]
        let mut object_221 = object.key("alertTargets").start_object();
        for (key_222, value_223) in var_220 {
            {
                #[allow(unused_mut)]
                let mut object_224 = object_221.key(key_222.as_str()).start_object();
                crate::json_ser::serialize_structure_crate_model_alert_target(
                    &mut object_224,
                    value_223,
                )?;
                object_224.finish();
            }
        }
        object_221.finish();
    }
    if let Some(var_225) = &input.behaviors {
        let mut array_226 = object.key("behaviors").start_array();
        for item_227 in var_225 {
            {
                #[allow(unused_mut)]
                let mut object_228 = array_226.value().start_object();
                crate::json_ser::serialize_structure_crate_model_behavior(
                    &mut object_228,
                    item_227,
                )?;
                object_228.finish();
            }
        }
        array_226.finish();
    }
    if let Some(var_229) = &input.security_profile_description {
        object
            .key("securityProfileDescription")
            .string(var_229.as_str());
    }
    if let Some(var_230) = &input.tags {
        let mut array_231 = object.key("tags").start_array();
        for item_232 in var_230 {
            {
                #[allow(unused_mut)]
                let mut object_233 = array_231.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_233, item_232)?;
                object_233.finish();
            }
        }
        array_231.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_stream_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateStreamInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_234) = &input.description {
        object.key("description").string(var_234.as_str());
    }
    if let Some(var_235) = &input.files {
        let mut array_236 = object.key("files").start_array();
        for item_237 in var_235 {
            {
                #[allow(unused_mut)]
                let mut object_238 = array_236.value().start_object();
                crate::json_ser::serialize_structure_crate_model_stream_file(
                    &mut object_238,
                    item_237,
                )?;
                object_238.finish();
            }
        }
        array_236.finish();
    }
    if let Some(var_239) = &input.role_arn {
        object.key("roleArn").string(var_239.as_str());
    }
    if let Some(var_240) = &input.tags {
        let mut array_241 = object.key("tags").start_array();
        for item_242 in var_240 {
            {
                #[allow(unused_mut)]
                let mut object_243 = array_241.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_243, item_242)?;
                object_243.finish();
            }
        }
        array_241.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_thing_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateThingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_244) = &input.attribute_payload {
        #[allow(unused_mut)]
        let mut object_245 = object.key("attributePayload").start_object();
        crate::json_ser::serialize_structure_crate_model_attribute_payload(
            &mut object_245,
            var_244,
        )?;
        object_245.finish();
    }
    if let Some(var_246) = &input.billing_group_name {
        object.key("billingGroupName").string(var_246.as_str());
    }
    if let Some(var_247) = &input.thing_type_name {
        object.key("thingTypeName").string(var_247.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_thing_group_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateThingGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_248) = &input.parent_group_name {
        object.key("parentGroupName").string(var_248.as_str());
    }
    if let Some(var_249) = &input.tags {
        let mut array_250 = object.key("tags").start_array();
        for item_251 in var_249 {
            {
                #[allow(unused_mut)]
                let mut object_252 = array_250.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_252, item_251)?;
                object_252.finish();
            }
        }
        array_250.finish();
    }
    if let Some(var_253) = &input.thing_group_properties {
        #[allow(unused_mut)]
        let mut object_254 = object.key("thingGroupProperties").start_object();
        crate::json_ser::serialize_structure_crate_model_thing_group_properties(
            &mut object_254,
            var_253,
        )?;
        object_254.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_thing_type_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateThingTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_255) = &input.tags {
        let mut array_256 = object.key("tags").start_array();
        for item_257 in var_255 {
            {
                #[allow(unused_mut)]
                let mut object_258 = array_256.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_258, item_257)?;
                object_258.finish();
            }
        }
        array_256.finish();
    }
    if let Some(var_259) = &input.thing_type_properties {
        #[allow(unused_mut)]
        let mut object_260 = object.key("thingTypeProperties").start_object();
        crate::json_ser::serialize_structure_crate_model_thing_type_properties(
            &mut object_260,
            var_259,
        )?;
        object_260.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_topic_rule_destination_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateTopicRuleDestinationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_261) = &input.destination_configuration {
        #[allow(unused_mut)]
        let mut object_262 = object.key("destinationConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_topic_rule_destination_configuration(
            &mut object_262,
            var_261,
        )?;
        object_262.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_audit_suppression_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteAuditSuppressionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_263) = &input.check_name {
        object.key("checkName").string(var_263.as_str());
    }
    if let Some(var_264) = &input.resource_identifier {
        #[allow(unused_mut)]
        let mut object_265 = object.key("resourceIdentifier").start_object();
        crate::json_ser::serialize_structure_crate_model_resource_identifier(
            &mut object_265,
            var_264,
        )?;
        object_265.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_deprecate_thing_type_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeprecateThingTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if input.undo_deprecate {
        object.key("undoDeprecate").boolean(input.undo_deprecate);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_audit_suppression_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeAuditSuppressionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_266) = &input.check_name {
        object.key("checkName").string(var_266.as_str());
    }
    if let Some(var_267) = &input.resource_identifier {
        #[allow(unused_mut)]
        let mut object_268 = object.key("resourceIdentifier").start_object();
        crate::json_ser::serialize_structure_crate_model_resource_identifier(
            &mut object_268,
            var_267,
        )?;
        object_268.finish();
    }
    Ok(())
}

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

pub fn serialize_structure_crate_input_get_buckets_aggregation_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetBucketsAggregationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_270) = &input.aggregation_field {
        object.key("aggregationField").string(var_270.as_str());
    }
    if let Some(var_271) = &input.buckets_aggregation_type {
        #[allow(unused_mut)]
        let mut object_272 = object.key("bucketsAggregationType").start_object();
        crate::json_ser::serialize_structure_crate_model_buckets_aggregation_type(
            &mut object_272,
            var_271,
        )?;
        object_272.finish();
    }
    if let Some(var_273) = &input.index_name {
        object.key("indexName").string(var_273.as_str());
    }
    if let Some(var_274) = &input.query_string {
        object.key("queryString").string(var_274.as_str());
    }
    if let Some(var_275) = &input.query_version {
        object.key("queryVersion").string(var_275.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_cardinality_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetCardinalityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_276) = &input.aggregation_field {
        object.key("aggregationField").string(var_276.as_str());
    }
    if let Some(var_277) = &input.index_name {
        object.key("indexName").string(var_277.as_str());
    }
    if let Some(var_278) = &input.query_string {
        object.key("queryString").string(var_278.as_str());
    }
    if let Some(var_279) = &input.query_version {
        object.key("queryVersion").string(var_279.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_effective_policies_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetEffectivePoliciesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_280) = &input.cognito_identity_pool_id {
        object.key("cognitoIdentityPoolId").string(var_280.as_str());
    }
    if let Some(var_281) = &input.principal {
        object.key("principal").string(var_281.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_percentiles_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetPercentilesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_282) = &input.aggregation_field {
        object.key("aggregationField").string(var_282.as_str());
    }
    if let Some(var_283) = &input.index_name {
        object.key("indexName").string(var_283.as_str());
    }
    if let Some(var_284) = &input.percents {
        let mut array_285 = object.key("percents").start_array();
        for item_286 in var_284 {
            {
                array_285.value().number(
                    #[allow(clippy::useless_conversion)]
                    aws_smithy_types::Number::Float((*item_286).into()),
                );
            }
        }
        array_285.finish();
    }
    if let Some(var_287) = &input.query_string {
        object.key("queryString").string(var_287.as_str());
    }
    if let Some(var_288) = &input.query_version {
        object.key("queryVersion").string(var_288.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_statistics_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetStatisticsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_289) = &input.aggregation_field {
        object.key("aggregationField").string(var_289.as_str());
    }
    if let Some(var_290) = &input.index_name {
        object.key("indexName").string(var_290.as_str());
    }
    if let Some(var_291) = &input.query_string {
        object.key("queryString").string(var_291.as_str());
    }
    if let Some(var_292) = &input.query_version {
        object.key("queryVersion").string(var_292.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_audit_findings_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListAuditFindingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_293) = &input.check_name {
        object.key("checkName").string(var_293.as_str());
    }
    if let Some(var_294) = &input.end_time {
        object
            .key("endTime")
            .date_time(var_294, aws_smithy_types::date_time::Format::EpochSeconds)?;
    }
    if input.list_suppressed_findings {
        object
            .key("listSuppressedFindings")
            .boolean(input.list_suppressed_findings);
    }
    if let Some(var_295) = &input.max_results {
        object.key("maxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_295).into()),
        );
    }
    if let Some(var_296) = &input.next_token {
        object.key("nextToken").string(var_296.as_str());
    }
    if let Some(var_297) = &input.resource_identifier {
        #[allow(unused_mut)]
        let mut object_298 = object.key("resourceIdentifier").start_object();
        crate::json_ser::serialize_structure_crate_model_resource_identifier(
            &mut object_298,
            var_297,
        )?;
        object_298.finish();
    }
    if let Some(var_299) = &input.start_time {
        object
            .key("startTime")
            .date_time(var_299, aws_smithy_types::date_time::Format::EpochSeconds)?;
    }
    if let Some(var_300) = &input.task_id {
        object.key("taskId").string(var_300.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_audit_suppressions_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListAuditSuppressionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if input.ascending_order {
        object.key("ascendingOrder").boolean(input.ascending_order);
    }
    if let Some(var_301) = &input.check_name {
        object.key("checkName").string(var_301.as_str());
    }
    if let Some(var_302) = &input.max_results {
        object.key("maxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_302).into()),
        );
    }
    if let Some(var_303) = &input.next_token {
        object.key("nextToken").string(var_303.as_str());
    }
    if let Some(var_304) = &input.resource_identifier {
        #[allow(unused_mut)]
        let mut object_305 = object.key("resourceIdentifier").start_object();
        crate::json_ser::serialize_structure_crate_model_resource_identifier(
            &mut object_305,
            var_304,
        )?;
        object_305.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_verification_state_on_violation_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutVerificationStateOnViolationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_306) = &input.verification_state {
        object.key("verificationState").string(var_306.as_str());
    }
    if let Some(var_307) = &input.verification_state_description {
        object
            .key("verificationStateDescription")
            .string(var_307.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_register_ca_certificate_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::RegisterCaCertificateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_308) = &input.ca_certificate {
        object.key("caCertificate").string(var_308.as_str());
    }
    if let Some(var_309) = &input.certificate_mode {
        object.key("certificateMode").string(var_309.as_str());
    }
    if let Some(var_310) = &input.registration_config {
        #[allow(unused_mut)]
        let mut object_311 = object.key("registrationConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_registration_config(
            &mut object_311,
            var_310,
        )?;
        object_311.finish();
    }
    if let Some(var_312) = &input.tags {
        let mut array_313 = object.key("tags").start_array();
        for item_314 in var_312 {
            {
                #[allow(unused_mut)]
                let mut object_315 = array_313.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_315, item_314)?;
                object_315.finish();
            }
        }
        array_313.finish();
    }
    if let Some(var_316) = &input.verification_certificate {
        object
            .key("verificationCertificate")
            .string(var_316.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_register_certificate_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::RegisterCertificateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_317) = &input.ca_certificate_pem {
        object.key("caCertificatePem").string(var_317.as_str());
    }
    if let Some(var_318) = &input.certificate_pem {
        object.key("certificatePem").string(var_318.as_str());
    }
    if let Some(var_319) = &input.status {
        object.key("status").string(var_319.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_register_certificate_without_ca_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::RegisterCertificateWithoutCaInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_320) = &input.certificate_pem {
        object.key("certificatePem").string(var_320.as_str());
    }
    if let Some(var_321) = &input.status {
        object.key("status").string(var_321.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_register_thing_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::RegisterThingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_322) = &input.parameters {
        #[allow(unused_mut)]
        let mut object_323 = object.key("parameters").start_object();
        for (key_324, value_325) in var_322 {
            {
                object_323.key(key_324.as_str()).string(value_325.as_str());
            }
        }
        object_323.finish();
    }
    if let Some(var_326) = &input.template_body {
        object.key("templateBody").string(var_326.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_reject_certificate_transfer_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::RejectCertificateTransferInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_327) = &input.reject_reason {
        object.key("rejectReason").string(var_327.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_remove_thing_from_billing_group_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::RemoveThingFromBillingGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_328) = &input.billing_group_arn {
        object.key("billingGroupArn").string(var_328.as_str());
    }
    if let Some(var_329) = &input.billing_group_name {
        object.key("billingGroupName").string(var_329.as_str());
    }
    if let Some(var_330) = &input.thing_arn {
        object.key("thingArn").string(var_330.as_str());
    }
    if let Some(var_331) = &input.thing_name {
        object.key("thingName").string(var_331.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_remove_thing_from_thing_group_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::RemoveThingFromThingGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_332) = &input.thing_arn {
        object.key("thingArn").string(var_332.as_str());
    }
    if let Some(var_333) = &input.thing_group_arn {
        object.key("thingGroupArn").string(var_333.as_str());
    }
    if let Some(var_334) = &input.thing_group_name {
        object.key("thingGroupName").string(var_334.as_str());
    }
    if let Some(var_335) = &input.thing_name {
        object.key("thingName").string(var_335.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_search_index_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::SearchIndexInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_336) = &input.index_name {
        object.key("indexName").string(var_336.as_str());
    }
    if let Some(var_337) = &input.max_results {
        object.key("maxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_337).into()),
        );
    }
    if let Some(var_338) = &input.next_token {
        object.key("nextToken").string(var_338.as_str());
    }
    if let Some(var_339) = &input.query_string {
        object.key("queryString").string(var_339.as_str());
    }
    if let Some(var_340) = &input.query_version {
        object.key("queryVersion").string(var_340.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_set_default_authorizer_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::SetDefaultAuthorizerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_341) = &input.authorizer_name {
        object.key("authorizerName").string(var_341.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_set_v2_logging_level_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::SetV2LoggingLevelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_342) = &input.log_level {
        object.key("logLevel").string(var_342.as_str());
    }
    if let Some(var_343) = &input.log_target {
        #[allow(unused_mut)]
        let mut object_344 = object.key("logTarget").start_object();
        crate::json_ser::serialize_structure_crate_model_log_target(&mut object_344, var_343)?;
        object_344.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_set_v2_logging_options_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::SetV2LoggingOptionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_345) = &input.default_log_level {
        object.key("defaultLogLevel").string(var_345.as_str());
    }
    if input.disable_all_logs {
        object.key("disableAllLogs").boolean(input.disable_all_logs);
    }
    if let Some(var_346) = &input.role_arn {
        object.key("roleArn").string(var_346.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_start_audit_mitigation_actions_task_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::StartAuditMitigationActionsTaskInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_347) = &input.audit_check_to_actions_mapping {
        #[allow(unused_mut)]
        let mut object_348 = object.key("auditCheckToActionsMapping").start_object();
        for (key_349, value_350) in var_347 {
            {
                let mut array_351 = object_348.key(key_349.as_str()).start_array();
                for item_352 in value_350 {
                    {
                        array_351.value().string(item_352.as_str());
                    }
                }
                array_351.finish();
            }
        }
        object_348.finish();
    }
    if let Some(var_353) = &input.client_request_token {
        object.key("clientRequestToken").string(var_353.as_str());
    }
    if let Some(var_354) = &input.target {
        #[allow(unused_mut)]
        let mut object_355 = object.key("target").start_object();
        crate::json_ser::serialize_structure_crate_model_audit_mitigation_actions_task_target(
            &mut object_355,
            var_354,
        )?;
        object_355.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_start_detect_mitigation_actions_task_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::StartDetectMitigationActionsTaskInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_356) = &input.actions {
        let mut array_357 = object.key("actions").start_array();
        for item_358 in var_356 {
            {
                array_357.value().string(item_358.as_str());
            }
        }
        array_357.finish();
    }
    if let Some(var_359) = &input.client_request_token {
        object.key("clientRequestToken").string(var_359.as_str());
    }
    if let Some(var_360) = &input.include_only_active_violations {
        object.key("includeOnlyActiveViolations").boolean(*var_360);
    }
    if let Some(var_361) = &input.include_suppressed_alerts {
        object.key("includeSuppressedAlerts").boolean(*var_361);
    }
    if let Some(var_362) = &input.target {
        #[allow(unused_mut)]
        let mut object_363 = object.key("target").start_object();
        crate::json_ser::serialize_structure_crate_model_detect_mitigation_actions_task_target(
            &mut object_363,
            var_362,
        )?;
        object_363.finish();
    }
    if let Some(var_364) = &input.violation_event_occurrence_range {
        #[allow(unused_mut)]
        let mut object_365 = object.key("violationEventOccurrenceRange").start_object();
        crate::json_ser::serialize_structure_crate_model_violation_event_occurrence_range(
            &mut object_365,
            var_364,
        )?;
        object_365.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_start_on_demand_audit_task_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::StartOnDemandAuditTaskInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_366) = &input.target_check_names {
        let mut array_367 = object.key("targetCheckNames").start_array();
        for item_368 in var_366 {
            {
                array_367.value().string(item_368.as_str());
            }
        }
        array_367.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_start_thing_registration_task_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::StartThingRegistrationTaskInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_369) = &input.input_file_bucket {
        object.key("inputFileBucket").string(var_369.as_str());
    }
    if let Some(var_370) = &input.input_file_key {
        object.key("inputFileKey").string(var_370.as_str());
    }
    if let Some(var_371) = &input.role_arn {
        object.key("roleArn").string(var_371.as_str());
    }
    if let Some(var_372) = &input.template_body {
        object.key("templateBody").string(var_372.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_373) = &input.resource_arn {
        object.key("resourceArn").string(var_373.as_str());
    }
    if let Some(var_374) = &input.tags {
        let mut array_375 = object.key("tags").start_array();
        for item_376 in var_374 {
            {
                #[allow(unused_mut)]
                let mut object_377 = array_375.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_377, item_376)?;
                object_377.finish();
            }
        }
        array_375.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_test_authorization_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::TestAuthorizationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_378) = &input.auth_infos {
        let mut array_379 = object.key("authInfos").start_array();
        for item_380 in var_378 {
            {
                #[allow(unused_mut)]
                let mut object_381 = array_379.value().start_object();
                crate::json_ser::serialize_structure_crate_model_auth_info(
                    &mut object_381,
                    item_380,
                )?;
                object_381.finish();
            }
        }
        array_379.finish();
    }
    if let Some(var_382) = &input.cognito_identity_pool_id {
        object.key("cognitoIdentityPoolId").string(var_382.as_str());
    }
    if let Some(var_383) = &input.policy_names_to_add {
        let mut array_384 = object.key("policyNamesToAdd").start_array();
        for item_385 in var_383 {
            {
                array_384.value().string(item_385.as_str());
            }
        }
        array_384.finish();
    }
    if let Some(var_386) = &input.policy_names_to_skip {
        let mut array_387 = object.key("policyNamesToSkip").start_array();
        for item_388 in var_386 {
            {
                array_387.value().string(item_388.as_str());
            }
        }
        array_387.finish();
    }
    if let Some(var_389) = &input.principal {
        object.key("principal").string(var_389.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_test_invoke_authorizer_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::TestInvokeAuthorizerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_390) = &input.http_context {
        #[allow(unused_mut)]
        let mut object_391 = object.key("httpContext").start_object();
        crate::json_ser::serialize_structure_crate_model_http_context(&mut object_391, var_390)?;
        object_391.finish();
    }
    if let Some(var_392) = &input.mqtt_context {
        #[allow(unused_mut)]
        let mut object_393 = object.key("mqttContext").start_object();
        crate::json_ser::serialize_structure_crate_model_mqtt_context(&mut object_393, var_392)?;
        object_393.finish();
    }
    if let Some(var_394) = &input.tls_context {
        #[allow(unused_mut)]
        let mut object_395 = object.key("tlsContext").start_object();
        crate::json_ser::serialize_structure_crate_model_tls_context(&mut object_395, var_394)?;
        object_395.finish();
    }
    if let Some(var_396) = &input.token {
        object.key("token").string(var_396.as_str());
    }
    if let Some(var_397) = &input.token_signature {
        object.key("tokenSignature").string(var_397.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_transfer_certificate_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::TransferCertificateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_398) = &input.transfer_message {
        object.key("transferMessage").string(var_398.as_str());
    }
    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_399) = &input.resource_arn {
        object.key("resourceArn").string(var_399.as_str());
    }
    if let Some(var_400) = &input.tag_keys {
        let mut array_401 = object.key("tagKeys").start_array();
        for item_402 in var_400 {
            {
                array_401.value().string(item_402.as_str());
            }
        }
        array_401.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_account_audit_configuration_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateAccountAuditConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_403) = &input.audit_check_configurations {
        #[allow(unused_mut)]
        let mut object_404 = object.key("auditCheckConfigurations").start_object();
        for (key_405, value_406) in var_403 {
            {
                #[allow(unused_mut)]
                let mut object_407 = object_404.key(key_405.as_str()).start_object();
                crate::json_ser::serialize_structure_crate_model_audit_check_configuration(
                    &mut object_407,
                    value_406,
                )?;
                object_407.finish();
            }
        }
        object_404.finish();
    }
    if let Some(var_408) = &input.audit_notification_target_configurations {
        #[allow(unused_mut)]
        let mut object_409 = object
            .key("auditNotificationTargetConfigurations")
            .start_object();
        for (key_410, value_411) in var_408 {
            {
                #[allow(unused_mut)]
                let mut object_412 = object_409.key(key_410.as_str()).start_object();
                crate::json_ser::serialize_structure_crate_model_audit_notification_target(
                    &mut object_412,
                    value_411,
                )?;
                object_412.finish();
            }
        }
        object_409.finish();
    }
    if let Some(var_413) = &input.role_arn {
        object.key("roleArn").string(var_413.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_audit_suppression_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateAuditSuppressionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_414) = &input.check_name {
        object.key("checkName").string(var_414.as_str());
    }
    if let Some(var_415) = &input.description {
        object.key("description").string(var_415.as_str());
    }
    if let Some(var_416) = &input.expiration_date {
        object
            .key("expirationDate")
            .date_time(var_416, aws_smithy_types::date_time::Format::EpochSeconds)?;
    }
    if let Some(var_417) = &input.resource_identifier {
        #[allow(unused_mut)]
        let mut object_418 = object.key("resourceIdentifier").start_object();
        crate::json_ser::serialize_structure_crate_model_resource_identifier(
            &mut object_418,
            var_417,
        )?;
        object_418.finish();
    }
    if let Some(var_419) = &input.suppress_indefinitely {
        object.key("suppressIndefinitely").boolean(*var_419);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_authorizer_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateAuthorizerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_420) = &input.authorizer_function_arn {
        object.key("authorizerFunctionArn").string(var_420.as_str());
    }
    if let Some(var_421) = &input.enable_caching_for_http {
        object.key("enableCachingForHttp").boolean(*var_421);
    }
    if let Some(var_422) = &input.status {
        object.key("status").string(var_422.as_str());
    }
    if let Some(var_423) = &input.token_key_name {
        object.key("tokenKeyName").string(var_423.as_str());
    }
    if let Some(var_424) = &input.token_signing_public_keys {
        #[allow(unused_mut)]
        let mut object_425 = object.key("tokenSigningPublicKeys").start_object();
        for (key_426, value_427) in var_424 {
            {
                object_425.key(key_426.as_str()).string(value_427.as_str());
            }
        }
        object_425.finish();
    }
    Ok(())
}

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

Returns all the &str values of the enum members.

Trait Implementations

impl AsRef<str> for AuthorizerStatus

fn as_ref(&self) -> &str

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

impl Clone for AuthorizerStatus

fn clone(&self) -> AuthorizerStatus

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AuthorizerStatus

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

Formats the value using the given formatter.

impl From<&str> for AuthorizerStatus

fn from(s: &str) -> Self

Converts to this type from the input type.

impl FromStr for AuthorizerStatus

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 AuthorizerStatus

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 AuthorizerStatus

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

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

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

impl StructuralEq for AuthorizerStatus

impl StructuralPartialEq for AuthorizerStatus