Enum aws_sdk_iot::model::LogLevel

#[non_exhaustive]
pub enum LogLevel {
    Debug,
    Disabled,
    Error,
    Info,
    Warn,
    Unknown(UnknownVariantValue),
}

When writing a match expression against LogLevel, 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 loglevel = unimplemented!();
match loglevel {
    LogLevel::Debug => { /* ... */ },
    LogLevel::Disabled => { /* ... */ },
    LogLevel::Error => { /* ... */ },
    LogLevel::Info => { /* ... */ },
    LogLevel::Warn => { /* ... */ },
    other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
    _ => { /* ... */ },
}

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

Debug

Disabled

Error

Info

Warn

Unknown(UnknownVariantValue)

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

Implementations

impl LogLevel

pub fn as_str(&self) -> &str

Returns the &str value of the enum member.

Examples found in repository

src/model.rs (line 2445)

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

src/json_ser.rs (line 1528)

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 fn serialize_structure_crate_input_update_billing_group_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateBillingGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_428) = &input.billing_group_properties {
        #[allow(unused_mut)]
        let mut object_429 = object.key("billingGroupProperties").start_object();
        crate::json_ser::serialize_structure_crate_model_billing_group_properties(
            &mut object_429,
            var_428,
        )?;
        object_429.finish();
    }
    if let Some(var_430) = &input.expected_version {
        object.key("expectedVersion").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_430).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_ca_certificate_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateCaCertificateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_431) = &input.registration_config {
        #[allow(unused_mut)]
        let mut object_432 = object.key("registrationConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_registration_config(
            &mut object_432,
            var_431,
        )?;
        object_432.finish();
    }
    if input.remove_auto_registration {
        object
            .key("removeAutoRegistration")
            .boolean(input.remove_auto_registration);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_custom_metric_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateCustomMetricInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_433) = &input.display_name {
        object.key("displayName").string(var_433.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_dimension_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateDimensionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_434) = &input.string_values {
        let mut array_435 = object.key("stringValues").start_array();
        for item_436 in var_434 {
            {
                array_435.value().string(item_436.as_str());
            }
        }
        array_435.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_domain_configuration_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateDomainConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_437) = &input.authorizer_config {
        #[allow(unused_mut)]
        let mut object_438 = object.key("authorizerConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_authorizer_config(
            &mut object_438,
            var_437,
        )?;
        object_438.finish();
    }
    if let Some(var_439) = &input.domain_configuration_status {
        object
            .key("domainConfigurationStatus")
            .string(var_439.as_str());
    }
    if input.remove_authorizer_config {
        object
            .key("removeAuthorizerConfig")
            .boolean(input.remove_authorizer_config);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_dynamic_thing_group_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateDynamicThingGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_440) = &input.expected_version {
        object.key("expectedVersion").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_440).into()),
        );
    }
    if let Some(var_441) = &input.index_name {
        object.key("indexName").string(var_441.as_str());
    }
    if let Some(var_442) = &input.query_string {
        object.key("queryString").string(var_442.as_str());
    }
    if let Some(var_443) = &input.query_version {
        object.key("queryVersion").string(var_443.as_str());
    }
    if let Some(var_444) = &input.thing_group_properties {
        #[allow(unused_mut)]
        let mut object_445 = object.key("thingGroupProperties").start_object();
        crate::json_ser::serialize_structure_crate_model_thing_group_properties(
            &mut object_445,
            var_444,
        )?;
        object_445.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_event_configurations_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateEventConfigurationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_446) = &input.event_configurations {
        #[allow(unused_mut)]
        let mut object_447 = object.key("eventConfigurations").start_object();
        for (key_448, value_449) in var_446 {
            {
                #[allow(unused_mut)]
                let mut object_450 = object_447.key(key_448.as_str()).start_object();
                crate::json_ser::serialize_structure_crate_model_configuration(
                    &mut object_450,
                    value_449,
                )?;
                object_450.finish();
            }
        }
        object_447.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_fleet_metric_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateFleetMetricInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_451) = &input.aggregation_field {
        object.key("aggregationField").string(var_451.as_str());
    }
    if let Some(var_452) = &input.aggregation_type {
        #[allow(unused_mut)]
        let mut object_453 = object.key("aggregationType").start_object();
        crate::json_ser::serialize_structure_crate_model_aggregation_type(
            &mut object_453,
            var_452,
        )?;
        object_453.finish();
    }
    if let Some(var_454) = &input.description {
        object.key("description").string(var_454.as_str());
    }
    if let Some(var_455) = &input.expected_version {
        object.key("expectedVersion").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_455).into()),
        );
    }
    if let Some(var_456) = &input.index_name {
        object.key("indexName").string(var_456.as_str());
    }
    if let Some(var_457) = &input.period {
        object.key("period").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_457).into()),
        );
    }
    if let Some(var_458) = &input.query_string {
        object.key("queryString").string(var_458.as_str());
    }
    if let Some(var_459) = &input.query_version {
        object.key("queryVersion").string(var_459.as_str());
    }
    if let Some(var_460) = &input.unit {
        object.key("unit").string(var_460.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_indexing_configuration_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateIndexingConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_461) = &input.thing_group_indexing_configuration {
        #[allow(unused_mut)]
        let mut object_462 = object.key("thingGroupIndexingConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_thing_group_indexing_configuration(
            &mut object_462,
            var_461,
        )?;
        object_462.finish();
    }
    if let Some(var_463) = &input.thing_indexing_configuration {
        #[allow(unused_mut)]
        let mut object_464 = object.key("thingIndexingConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_thing_indexing_configuration(
            &mut object_464,
            var_463,
        )?;
        object_464.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_job_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_465) = &input.abort_config {
        #[allow(unused_mut)]
        let mut object_466 = object.key("abortConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_abort_config(&mut object_466, var_465)?;
        object_466.finish();
    }
    if let Some(var_467) = &input.description {
        object.key("description").string(var_467.as_str());
    }
    if let Some(var_468) = &input.job_executions_retry_config {
        #[allow(unused_mut)]
        let mut object_469 = object.key("jobExecutionsRetryConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_job_executions_retry_config(
            &mut object_469,
            var_468,
        )?;
        object_469.finish();
    }
    if let Some(var_470) = &input.job_executions_rollout_config {
        #[allow(unused_mut)]
        let mut object_471 = object.key("jobExecutionsRolloutConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_job_executions_rollout_config(
            &mut object_471,
            var_470,
        )?;
        object_471.finish();
    }
    if let Some(var_472) = &input.presigned_url_config {
        #[allow(unused_mut)]
        let mut object_473 = object.key("presignedUrlConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_presigned_url_config(
            &mut object_473,
            var_472,
        )?;
        object_473.finish();
    }
    if let Some(var_474) = &input.timeout_config {
        #[allow(unused_mut)]
        let mut object_475 = object.key("timeoutConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_timeout_config(&mut object_475, var_474)?;
        object_475.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_mitigation_action_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateMitigationActionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_476) = &input.action_params {
        #[allow(unused_mut)]
        let mut object_477 = object.key("actionParams").start_object();
        crate::json_ser::serialize_structure_crate_model_mitigation_action_params(
            &mut object_477,
            var_476,
        )?;
        object_477.finish();
    }
    if let Some(var_478) = &input.role_arn {
        object.key("roleArn").string(var_478.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_provisioning_template_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateProvisioningTemplateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_479) = &input.default_version_id {
        object.key("defaultVersionId").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_479).into()),
        );
    }
    if let Some(var_480) = &input.description {
        object.key("description").string(var_480.as_str());
    }
    if input.enabled {
        object.key("enabled").boolean(input.enabled);
    }
    if let Some(var_481) = &input.pre_provisioning_hook {
        #[allow(unused_mut)]
        let mut object_482 = object.key("preProvisioningHook").start_object();
        crate::json_ser::serialize_structure_crate_model_provisioning_hook(
            &mut object_482,
            var_481,
        )?;
        object_482.finish();
    }
    if let Some(var_483) = &input.provisioning_role_arn {
        object.key("provisioningRoleArn").string(var_483.as_str());
    }
    if let Some(var_484) = &input.remove_pre_provisioning_hook {
        object.key("removePreProvisioningHook").boolean(*var_484);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_role_alias_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateRoleAliasInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_485) = &input.credential_duration_seconds {
        object.key("credentialDurationSeconds").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_485).into()),
        );
    }
    if let Some(var_486) = &input.role_arn {
        object.key("roleArn").string(var_486.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_scheduled_audit_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateScheduledAuditInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_487) = &input.day_of_month {
        object.key("dayOfMonth").string(var_487.as_str());
    }
    if let Some(var_488) = &input.day_of_week {
        object.key("dayOfWeek").string(var_488.as_str());
    }
    if let Some(var_489) = &input.frequency {
        object.key("frequency").string(var_489.as_str());
    }
    if let Some(var_490) = &input.target_check_names {
        let mut array_491 = object.key("targetCheckNames").start_array();
        for item_492 in var_490 {
            {
                array_491.value().string(item_492.as_str());
            }
        }
        array_491.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_security_profile_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateSecurityProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_493) = &input.additional_metrics_to_retain {
        let mut array_494 = object.key("additionalMetricsToRetain").start_array();
        for item_495 in var_493 {
            {
                array_494.value().string(item_495.as_str());
            }
        }
        array_494.finish();
    }
    if let Some(var_496) = &input.additional_metrics_to_retain_v2 {
        let mut array_497 = object.key("additionalMetricsToRetainV2").start_array();
        for item_498 in var_496 {
            {
                #[allow(unused_mut)]
                let mut object_499 = array_497.value().start_object();
                crate::json_ser::serialize_structure_crate_model_metric_to_retain(
                    &mut object_499,
                    item_498,
                )?;
                object_499.finish();
            }
        }
        array_497.finish();
    }
    if let Some(var_500) = &input.alert_targets {
        #[allow(unused_mut)]
        let mut object_501 = object.key("alertTargets").start_object();
        for (key_502, value_503) in var_500 {
            {
                #[allow(unused_mut)]
                let mut object_504 = object_501.key(key_502.as_str()).start_object();
                crate::json_ser::serialize_structure_crate_model_alert_target(
                    &mut object_504,
                    value_503,
                )?;
                object_504.finish();
            }
        }
        object_501.finish();
    }
    if let Some(var_505) = &input.behaviors {
        let mut array_506 = object.key("behaviors").start_array();
        for item_507 in var_505 {
            {
                #[allow(unused_mut)]
                let mut object_508 = array_506.value().start_object();
                crate::json_ser::serialize_structure_crate_model_behavior(
                    &mut object_508,
                    item_507,
                )?;
                object_508.finish();
            }
        }
        array_506.finish();
    }
    if input.delete_additional_metrics_to_retain {
        object
            .key("deleteAdditionalMetricsToRetain")
            .boolean(input.delete_additional_metrics_to_retain);
    }
    if input.delete_alert_targets {
        object
            .key("deleteAlertTargets")
            .boolean(input.delete_alert_targets);
    }
    if input.delete_behaviors {
        object
            .key("deleteBehaviors")
            .boolean(input.delete_behaviors);
    }
    if let Some(var_509) = &input.security_profile_description {
        object
            .key("securityProfileDescription")
            .string(var_509.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_stream_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateStreamInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_510) = &input.description {
        object.key("description").string(var_510.as_str());
    }
    if let Some(var_511) = &input.files {
        let mut array_512 = object.key("files").start_array();
        for item_513 in var_511 {
            {
                #[allow(unused_mut)]
                let mut object_514 = array_512.value().start_object();
                crate::json_ser::serialize_structure_crate_model_stream_file(
                    &mut object_514,
                    item_513,
                )?;
                object_514.finish();
            }
        }
        array_512.finish();
    }
    if let Some(var_515) = &input.role_arn {
        object.key("roleArn").string(var_515.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_thing_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateThingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_516) = &input.attribute_payload {
        #[allow(unused_mut)]
        let mut object_517 = object.key("attributePayload").start_object();
        crate::json_ser::serialize_structure_crate_model_attribute_payload(
            &mut object_517,
            var_516,
        )?;
        object_517.finish();
    }
    if let Some(var_518) = &input.expected_version {
        object.key("expectedVersion").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_518).into()),
        );
    }
    if input.remove_thing_type {
        object
            .key("removeThingType")
            .boolean(input.remove_thing_type);
    }
    if let Some(var_519) = &input.thing_type_name {
        object.key("thingTypeName").string(var_519.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_thing_group_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateThingGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_520) = &input.expected_version {
        object.key("expectedVersion").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_520).into()),
        );
    }
    if let Some(var_521) = &input.thing_group_properties {
        #[allow(unused_mut)]
        let mut object_522 = object.key("thingGroupProperties").start_object();
        crate::json_ser::serialize_structure_crate_model_thing_group_properties(
            &mut object_522,
            var_521,
        )?;
        object_522.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_thing_groups_for_thing_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateThingGroupsForThingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if input.override_dynamic_groups {
        object
            .key("overrideDynamicGroups")
            .boolean(input.override_dynamic_groups);
    }
    if let Some(var_523) = &input.thing_groups_to_add {
        let mut array_524 = object.key("thingGroupsToAdd").start_array();
        for item_525 in var_523 {
            {
                array_524.value().string(item_525.as_str());
            }
        }
        array_524.finish();
    }
    if let Some(var_526) = &input.thing_groups_to_remove {
        let mut array_527 = object.key("thingGroupsToRemove").start_array();
        for item_528 in var_526 {
            {
                array_527.value().string(item_528.as_str());
            }
        }
        array_527.finish();
    }
    if let Some(var_529) = &input.thing_name {
        object.key("thingName").string(var_529.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_topic_rule_destination_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateTopicRuleDestinationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_530) = &input.arn {
        object.key("arn").string(var_530.as_str());
    }
    if let Some(var_531) = &input.status {
        object.key("status").string(var_531.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_validate_security_profile_behaviors_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ValidateSecurityProfileBehaviorsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_532) = &input.behaviors {
        let mut array_533 = object.key("behaviors").start_array();
        for item_534 in var_532 {
            {
                #[allow(unused_mut)]
                let mut object_535 = array_533.value().start_object();
                crate::json_ser::serialize_structure_crate_model_behavior(
                    &mut object_535,
                    item_534,
                )?;
                object_535.finish();
            }
        }
        array_533.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_resource_identifier(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ResourceIdentifier,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_536) = &input.device_certificate_id {
        object.key("deviceCertificateId").string(var_536.as_str());
    }
    if let Some(var_537) = &input.ca_certificate_id {
        object.key("caCertificateId").string(var_537.as_str());
    }
    if let Some(var_538) = &input.cognito_identity_pool_id {
        object.key("cognitoIdentityPoolId").string(var_538.as_str());
    }
    if let Some(var_539) = &input.client_id {
        object.key("clientId").string(var_539.as_str());
    }
    if let Some(var_540) = &input.policy_version_identifier {
        #[allow(unused_mut)]
        let mut object_541 = object.key("policyVersionIdentifier").start_object();
        crate::json_ser::serialize_structure_crate_model_policy_version_identifier(
            &mut object_541,
            var_540,
        )?;
        object_541.finish();
    }
    if let Some(var_542) = &input.account {
        object.key("account").string(var_542.as_str());
    }
    if let Some(var_543) = &input.iam_role_arn {
        object.key("iamRoleArn").string(var_543.as_str());
    }
    if let Some(var_544) = &input.role_alias_arn {
        object.key("roleAliasArn").string(var_544.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_tag(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_545) = &input.key {
        object.key("Key").string(var_545.as_str());
    }
    if let Some(var_546) = &input.value {
        object.key("Value").string(var_546.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_billing_group_properties(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::BillingGroupProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_547) = &input.billing_group_description {
        object
            .key("billingGroupDescription")
            .string(var_547.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_authorizer_config(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AuthorizerConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_548) = &input.default_authorizer_name {
        object.key("defaultAuthorizerName").string(var_548.as_str());
    }
    if let Some(var_549) = &input.allow_authorizer_override {
        object.key("allowAuthorizerOverride").boolean(*var_549);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_thing_group_properties(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ThingGroupProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_550) = &input.thing_group_description {
        object.key("thingGroupDescription").string(var_550.as_str());
    }
    if let Some(var_551) = &input.attribute_payload {
        #[allow(unused_mut)]
        let mut object_552 = object.key("attributePayload").start_object();
        crate::json_ser::serialize_structure_crate_model_attribute_payload(
            &mut object_552,
            var_551,
        )?;
        object_552.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_aggregation_type(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AggregationType,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_553) = &input.name {
        object.key("name").string(var_553.as_str());
    }
    if let Some(var_554) = &input.values {
        let mut array_555 = object.key("values").start_array();
        for item_556 in var_554 {
            {
                array_555.value().string(item_556.as_str());
            }
        }
        array_555.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_abort_config(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AbortConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_557) = &input.criteria_list {
        let mut array_558 = object.key("criteriaList").start_array();
        for item_559 in var_557 {
            {
                #[allow(unused_mut)]
                let mut object_560 = array_558.value().start_object();
                crate::json_ser::serialize_structure_crate_model_abort_criteria(
                    &mut object_560,
                    item_559,
                )?;
                object_560.finish();
            }
        }
        array_558.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_job_executions_retry_config(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::JobExecutionsRetryConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_561) = &input.criteria_list {
        let mut array_562 = object.key("criteriaList").start_array();
        for item_563 in var_561 {
            {
                #[allow(unused_mut)]
                let mut object_564 = array_562.value().start_object();
                crate::json_ser::serialize_structure_crate_model_retry_criteria(
                    &mut object_564,
                    item_563,
                )?;
                object_564.finish();
            }
        }
        array_562.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_job_executions_rollout_config(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::JobExecutionsRolloutConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_565) = &input.maximum_per_minute {
        object.key("maximumPerMinute").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_565).into()),
        );
    }
    if let Some(var_566) = &input.exponential_rate {
        #[allow(unused_mut)]
        let mut object_567 = object.key("exponentialRate").start_object();
        crate::json_ser::serialize_structure_crate_model_exponential_rollout_rate(
            &mut object_567,
            var_566,
        )?;
        object_567.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_presigned_url_config(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::PresignedUrlConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_568) = &input.role_arn {
        object.key("roleArn").string(var_568.as_str());
    }
    if let Some(var_569) = &input.expires_in_sec {
        object.key("expiresInSec").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_569).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_timeout_config(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TimeoutConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_570) = &input.in_progress_timeout_in_minutes {
        object.key("inProgressTimeoutInMinutes").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_570).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_mitigation_action_params(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MitigationActionParams,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_571) = &input.update_device_certificate_params {
        #[allow(unused_mut)]
        let mut object_572 = object.key("updateDeviceCertificateParams").start_object();
        crate::json_ser::serialize_structure_crate_model_update_device_certificate_params(
            &mut object_572,
            var_571,
        )?;
        object_572.finish();
    }
    if let Some(var_573) = &input.update_ca_certificate_params {
        #[allow(unused_mut)]
        let mut object_574 = object.key("updateCACertificateParams").start_object();
        crate::json_ser::serialize_structure_crate_model_update_ca_certificate_params(
            &mut object_574,
            var_573,
        )?;
        object_574.finish();
    }
    if let Some(var_575) = &input.add_things_to_thing_group_params {
        #[allow(unused_mut)]
        let mut object_576 = object.key("addThingsToThingGroupParams").start_object();
        crate::json_ser::serialize_structure_crate_model_add_things_to_thing_group_params(
            &mut object_576,
            var_575,
        )?;
        object_576.finish();
    }
    if let Some(var_577) = &input.replace_default_policy_version_params {
        #[allow(unused_mut)]
        let mut object_578 = object
            .key("replaceDefaultPolicyVersionParams")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_replace_default_policy_version_params(
            &mut object_578,
            var_577,
        )?;
        object_578.finish();
    }
    if let Some(var_579) = &input.enable_io_t_logging_params {
        #[allow(unused_mut)]
        let mut object_580 = object.key("enableIoTLoggingParams").start_object();
        crate::json_ser::serialize_structure_crate_model_enable_io_t_logging_params(
            &mut object_580,
            var_579,
        )?;
        object_580.finish();
    }
    if let Some(var_581) = &input.publish_finding_to_sns_params {
        #[allow(unused_mut)]
        let mut object_582 = object.key("publishFindingToSnsParams").start_object();
        crate::json_ser::serialize_structure_crate_model_publish_finding_to_sns_params(
            &mut object_582,
            var_581,
        )?;
        object_582.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_aws_job_abort_config(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsJobAbortConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_583) = &input.abort_criteria_list {
        let mut array_584 = object.key("abortCriteriaList").start_array();
        for item_585 in var_583 {
            {
                #[allow(unused_mut)]
                let mut object_586 = array_584.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_job_abort_criteria(
                    &mut object_586,
                    item_585,
                )?;
                object_586.finish();
            }
        }
        array_584.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_aws_job_executions_rollout_config(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsJobExecutionsRolloutConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_587) = &input.maximum_per_minute {
        object.key("maximumPerMinute").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_587).into()),
        );
    }
    if let Some(var_588) = &input.exponential_rate {
        #[allow(unused_mut)]
        let mut object_589 = object.key("exponentialRate").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_job_exponential_rollout_rate(
            &mut object_589,
            var_588,
        )?;
        object_589.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_aws_job_presigned_url_config(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsJobPresignedUrlConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_590) = &input.expires_in_sec {
        object.key("expiresInSec").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_590).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_aws_job_timeout_config(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsJobTimeoutConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_591) = &input.in_progress_timeout_in_minutes {
        object.key("inProgressTimeoutInMinutes").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_591).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_ota_update_file(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::OtaUpdateFile,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_592) = &input.file_name {
        object.key("fileName").string(var_592.as_str());
    }
    if let Some(var_593) = &input.file_type {
        object.key("fileType").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_593).into()),
        );
    }
    if let Some(var_594) = &input.file_version {
        object.key("fileVersion").string(var_594.as_str());
    }
    if let Some(var_595) = &input.file_location {
        #[allow(unused_mut)]
        let mut object_596 = object.key("fileLocation").start_object();
        crate::json_ser::serialize_structure_crate_model_file_location(&mut object_596, var_595)?;
        object_596.finish();
    }
    if let Some(var_597) = &input.code_signing {
        #[allow(unused_mut)]
        let mut object_598 = object.key("codeSigning").start_object();
        crate::json_ser::serialize_structure_crate_model_code_signing(&mut object_598, var_597)?;
        object_598.finish();
    }
    if let Some(var_599) = &input.attributes {
        #[allow(unused_mut)]
        let mut object_600 = object.key("attributes").start_object();
        for (key_601, value_602) in var_599 {
            {
                object_600.key(key_601.as_str()).string(value_602.as_str());
            }
        }
        object_600.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_provisioning_hook(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ProvisioningHook,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_603) = &input.payload_version {
        object.key("payloadVersion").string(var_603.as_str());
    }
    if let Some(var_604) = &input.target_arn {
        object.key("targetArn").string(var_604.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_metric_to_retain(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MetricToRetain,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_605) = &input.metric {
        object.key("metric").string(var_605.as_str());
    }
    if let Some(var_606) = &input.metric_dimension {
        #[allow(unused_mut)]
        let mut object_607 = object.key("metricDimension").start_object();
        crate::json_ser::serialize_structure_crate_model_metric_dimension(
            &mut object_607,
            var_606,
        )?;
        object_607.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_alert_target(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AlertTarget,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_608) = &input.alert_target_arn {
        object.key("alertTargetArn").string(var_608.as_str());
    }
    if let Some(var_609) = &input.role_arn {
        object.key("roleArn").string(var_609.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_behavior(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Behavior,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_610) = &input.name {
        object.key("name").string(var_610.as_str());
    }
    if let Some(var_611) = &input.metric {
        object.key("metric").string(var_611.as_str());
    }
    if let Some(var_612) = &input.metric_dimension {
        #[allow(unused_mut)]
        let mut object_613 = object.key("metricDimension").start_object();
        crate::json_ser::serialize_structure_crate_model_metric_dimension(
            &mut object_613,
            var_612,
        )?;
        object_613.finish();
    }
    if let Some(var_614) = &input.criteria {
        #[allow(unused_mut)]
        let mut object_615 = object.key("criteria").start_object();
        crate::json_ser::serialize_structure_crate_model_behavior_criteria(
            &mut object_615,
            var_614,
        )?;
        object_615.finish();
    }
    if let Some(var_616) = &input.suppress_alerts {
        object.key("suppressAlerts").boolean(*var_616);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_stream_file(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::StreamFile,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_617) = &input.file_id {
        object.key("fileId").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_617).into()),
        );
    }
    if let Some(var_618) = &input.s3_location {
        #[allow(unused_mut)]
        let mut object_619 = object.key("s3Location").start_object();
        crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_619, var_618)?;
        object_619.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_attribute_payload(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AttributePayload,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_620) = &input.attributes {
        #[allow(unused_mut)]
        let mut object_621 = object.key("attributes").start_object();
        for (key_622, value_623) in var_620 {
            {
                object_621.key(key_622.as_str()).string(value_623.as_str());
            }
        }
        object_621.finish();
    }
    if input.merge {
        object.key("merge").boolean(input.merge);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_thing_type_properties(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ThingTypeProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_624) = &input.thing_type_description {
        object.key("thingTypeDescription").string(var_624.as_str());
    }
    if let Some(var_625) = &input.searchable_attributes {
        let mut array_626 = object.key("searchableAttributes").start_array();
        for item_627 in var_625 {
            {
                array_626.value().string(item_627.as_str());
            }
        }
        array_626.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_topic_rule_destination_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TopicRuleDestinationConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_628) = &input.http_url_configuration {
        #[allow(unused_mut)]
        let mut object_629 = object.key("httpUrlConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_http_url_destination_configuration(
            &mut object_629,
            var_628,
        )?;
        object_629.finish();
    }
    if let Some(var_630) = &input.vpc_configuration {
        #[allow(unused_mut)]
        let mut object_631 = object.key("vpcConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_vpc_destination_configuration(
            &mut object_631,
            var_630,
        )?;
        object_631.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_buckets_aggregation_type(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::BucketsAggregationType,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_632) = &input.terms_aggregation {
        #[allow(unused_mut)]
        let mut object_633 = object.key("termsAggregation").start_object();
        crate::json_ser::serialize_structure_crate_model_terms_aggregation(
            &mut object_633,
            var_632,
        )?;
        object_633.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_registration_config(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::RegistrationConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_634) = &input.template_body {
        object.key("templateBody").string(var_634.as_str());
    }
    if let Some(var_635) = &input.role_arn {
        object.key("roleArn").string(var_635.as_str());
    }
    if let Some(var_636) = &input.template_name {
        object.key("templateName").string(var_636.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_log_target(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::LogTarget,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_637) = &input.target_type {
        object.key("targetType").string(var_637.as_str());
    }
    if let Some(var_638) = &input.target_name {
        object.key("targetName").string(var_638.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_audit_mitigation_actions_task_target(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AuditMitigationActionsTaskTarget,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_639) = &input.audit_task_id {
        object.key("auditTaskId").string(var_639.as_str());
    }
    if let Some(var_640) = &input.finding_ids {
        let mut array_641 = object.key("findingIds").start_array();
        for item_642 in var_640 {
            {
                array_641.value().string(item_642.as_str());
            }
        }
        array_641.finish();
    }
    if let Some(var_643) = &input.audit_check_to_reason_code_filter {
        #[allow(unused_mut)]
        let mut object_644 = object.key("auditCheckToReasonCodeFilter").start_object();
        for (key_645, value_646) in var_643 {
            {
                let mut array_647 = object_644.key(key_645.as_str()).start_array();
                for item_648 in value_646 {
                    {
                        array_647.value().string(item_648.as_str());
                    }
                }
                array_647.finish();
            }
        }
        object_644.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_detect_mitigation_actions_task_target(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DetectMitigationActionsTaskTarget,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_649) = &input.violation_ids {
        let mut array_650 = object.key("violationIds").start_array();
        for item_651 in var_649 {
            {
                array_650.value().string(item_651.as_str());
            }
        }
        array_650.finish();
    }
    if let Some(var_652) = &input.security_profile_name {
        object.key("securityProfileName").string(var_652.as_str());
    }
    if let Some(var_653) = &input.behavior_name {
        object.key("behaviorName").string(var_653.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_violation_event_occurrence_range(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ViolationEventOccurrenceRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_654) = &input.start_time {
        object
            .key("startTime")
            .date_time(var_654, aws_smithy_types::date_time::Format::EpochSeconds)?;
    }
    if let Some(var_655) = &input.end_time {
        object
            .key("endTime")
            .date_time(var_655, aws_smithy_types::date_time::Format::EpochSeconds)?;
    }
    Ok(())
}

pub fn serialize_structure_crate_model_auth_info(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AuthInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_656) = &input.action_type {
        object.key("actionType").string(var_656.as_str());
    }
    if let Some(var_657) = &input.resources {
        let mut array_658 = object.key("resources").start_array();
        for item_659 in var_657 {
            {
                array_658.value().string(item_659.as_str());
            }
        }
        array_658.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_http_context(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HttpContext,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_660) = &input.headers {
        #[allow(unused_mut)]
        let mut object_661 = object.key("headers").start_object();
        for (key_662, value_663) in var_660 {
            {
                object_661.key(key_662.as_str()).string(value_663.as_str());
            }
        }
        object_661.finish();
    }
    if let Some(var_664) = &input.query_string {
        object.key("queryString").string(var_664.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_mqtt_context(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MqttContext,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_665) = &input.username {
        object.key("username").string(var_665.as_str());
    }
    if let Some(var_666) = &input.password {
        object
            .key("password")
            .string_unchecked(&aws_smithy_types::base64::encode(var_666));
    }
    if let Some(var_667) = &input.client_id {
        object.key("clientId").string(var_667.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_tls_context(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TlsContext,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_668) = &input.server_name {
        object.key("serverName").string(var_668.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_audit_check_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AuditCheckConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if input.enabled {
        object.key("enabled").boolean(input.enabled);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_audit_notification_target(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AuditNotificationTarget,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_669) = &input.target_arn {
        object.key("targetArn").string(var_669.as_str());
    }
    if let Some(var_670) = &input.role_arn {
        object.key("roleArn").string(var_670.as_str());
    }
    if input.enabled {
        object.key("enabled").boolean(input.enabled);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Configuration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if input.enabled {
        object.key("Enabled").boolean(input.enabled);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_thing_group_indexing_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ThingGroupIndexingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_671) = &input.thing_group_indexing_mode {
        object
            .key("thingGroupIndexingMode")
            .string(var_671.as_str());
    }
    if let Some(var_672) = &input.managed_fields {
        let mut array_673 = object.key("managedFields").start_array();
        for item_674 in var_672 {
            {
                #[allow(unused_mut)]
                let mut object_675 = array_673.value().start_object();
                crate::json_ser::serialize_structure_crate_model_field(&mut object_675, item_674)?;
                object_675.finish();
            }
        }
        array_673.finish();
    }
    if let Some(var_676) = &input.custom_fields {
        let mut array_677 = object.key("customFields").start_array();
        for item_678 in var_676 {
            {
                #[allow(unused_mut)]
                let mut object_679 = array_677.value().start_object();
                crate::json_ser::serialize_structure_crate_model_field(&mut object_679, item_678)?;
                object_679.finish();
            }
        }
        array_677.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_thing_indexing_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ThingIndexingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_680) = &input.thing_indexing_mode {
        object.key("thingIndexingMode").string(var_680.as_str());
    }
    if let Some(var_681) = &input.thing_connectivity_indexing_mode {
        object
            .key("thingConnectivityIndexingMode")
            .string(var_681.as_str());
    }
    if let Some(var_682) = &input.device_defender_indexing_mode {
        object
            .key("deviceDefenderIndexingMode")
            .string(var_682.as_str());
    }
    if let Some(var_683) = &input.named_shadow_indexing_mode {
        object
            .key("namedShadowIndexingMode")
            .string(var_683.as_str());
    }
    if let Some(var_684) = &input.managed_fields {
        let mut array_685 = object.key("managedFields").start_array();
        for item_686 in var_684 {
            {
                #[allow(unused_mut)]
                let mut object_687 = array_685.value().start_object();
                crate::json_ser::serialize_structure_crate_model_field(&mut object_687, item_686)?;
                object_687.finish();
            }
        }
        array_685.finish();
    }
    if let Some(var_688) = &input.custom_fields {
        let mut array_689 = object.key("customFields").start_array();
        for item_690 in var_688 {
            {
                #[allow(unused_mut)]
                let mut object_691 = array_689.value().start_object();
                crate::json_ser::serialize_structure_crate_model_field(&mut object_691, item_690)?;
                object_691.finish();
            }
        }
        array_689.finish();
    }
    if let Some(var_692) = &input.filter {
        #[allow(unused_mut)]
        let mut object_693 = object.key("filter").start_object();
        crate::json_ser::serialize_structure_crate_model_indexing_filter(&mut object_693, var_692)?;
        object_693.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_topic_rule_payload(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TopicRulePayload,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_694) = &input.sql {
        object.key("sql").string(var_694.as_str());
    }
    if let Some(var_695) = &input.description {
        object.key("description").string(var_695.as_str());
    }
    if let Some(var_696) = &input.actions {
        let mut array_697 = object.key("actions").start_array();
        for item_698 in var_696 {
            {
                #[allow(unused_mut)]
                let mut object_699 = array_697.value().start_object();
                crate::json_ser::serialize_structure_crate_model_action(&mut object_699, item_698)?;
                object_699.finish();
            }
        }
        array_697.finish();
    }
    if let Some(var_700) = &input.rule_disabled {
        object.key("ruleDisabled").boolean(*var_700);
    }
    if let Some(var_701) = &input.aws_iot_sql_version {
        object.key("awsIotSqlVersion").string(var_701.as_str());
    }
    if let Some(var_702) = &input.error_action {
        #[allow(unused_mut)]
        let mut object_703 = object.key("errorAction").start_object();
        crate::json_ser::serialize_structure_crate_model_action(&mut object_703, var_702)?;
        object_703.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_logging_options_payload(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::LoggingOptionsPayload,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_704) = &input.role_arn {
        object.key("roleArn").string(var_704.as_str());
    }
    if let Some(var_705) = &input.log_level {
        object.key("logLevel").string(var_705.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_policy_version_identifier(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::PolicyVersionIdentifier,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_706) = &input.policy_name {
        object.key("policyName").string(var_706.as_str());
    }
    if let Some(var_707) = &input.policy_version_id {
        object.key("policyVersionId").string(var_707.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_abort_criteria(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AbortCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_708) = &input.failure_type {
        object.key("failureType").string(var_708.as_str());
    }
    if let Some(var_709) = &input.action {
        object.key("action").string(var_709.as_str());
    }
    if let Some(var_710) = &input.threshold_percentage {
        object.key("thresholdPercentage").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_710).into()),
        );
    }
    if let Some(var_711) = &input.min_number_of_executed_things {
        object.key("minNumberOfExecutedThings").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_711).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_retry_criteria(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::RetryCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_712) = &input.failure_type {
        object.key("failureType").string(var_712.as_str());
    }
    if let Some(var_713) = &input.number_of_retries {
        object.key("numberOfRetries").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_713).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_exponential_rollout_rate(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ExponentialRolloutRate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_714) = &input.base_rate_per_minute {
        object.key("baseRatePerMinute").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_714).into()),
        );
    }
    {
        object.key("incrementFactor").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.increment_factor).into()),
        );
    }
    if let Some(var_715) = &input.rate_increase_criteria {
        #[allow(unused_mut)]
        let mut object_716 = object.key("rateIncreaseCriteria").start_object();
        crate::json_ser::serialize_structure_crate_model_rate_increase_criteria(
            &mut object_716,
            var_715,
        )?;
        object_716.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_update_device_certificate_params(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::UpdateDeviceCertificateParams,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_717) = &input.action {
        object.key("action").string(var_717.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_update_ca_certificate_params(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::UpdateCaCertificateParams,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_718) = &input.action {
        object.key("action").string(var_718.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_add_things_to_thing_group_params(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AddThingsToThingGroupParams,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_719) = &input.thing_group_names {
        let mut array_720 = object.key("thingGroupNames").start_array();
        for item_721 in var_719 {
            {
                array_720.value().string(item_721.as_str());
            }
        }
        array_720.finish();
    }
    if let Some(var_722) = &input.override_dynamic_groups {
        object.key("overrideDynamicGroups").boolean(*var_722);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_replace_default_policy_version_params(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ReplaceDefaultPolicyVersionParams,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_723) = &input.template_name {
        object.key("templateName").string(var_723.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_enable_io_t_logging_params(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::EnableIoTLoggingParams,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_724) = &input.role_arn_for_logging {
        object.key("roleArnForLogging").string(var_724.as_str());
    }
    if let Some(var_725) = &input.log_level {
        object.key("logLevel").string(var_725.as_str());
    }
    Ok(())
}

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

Returns all the &str values of the enum members.

Trait Implementations

impl AsRef<str> for LogLevel

fn as_ref(&self) -> &str

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

impl Clone for LogLevel

fn clone(&self) -> LogLevel

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LogLevel

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

Formats the value using the given formatter.

impl From<&str> for LogLevel

fn from(s: &str) -> Self

Converts to this type from the input type.

impl FromStr for LogLevel

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 LogLevel

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 LogLevel

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

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

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

impl StructuralEq for LogLevel

impl StructuralPartialEq for LogLevel