Enum aws_sdk_securityhub::model::WorkflowStatus

#[non_exhaustive]
pub enum WorkflowStatus {
    New,
    Notified,
    Resolved,
    Suppressed,
    Unknown(UnknownVariantValue),
}

When writing a match expression against WorkflowStatus, 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 workflowstatus = unimplemented!();
match workflowstatus {
    WorkflowStatus::New => { /* ... */ },
    WorkflowStatus::Notified => { /* ... */ },
    WorkflowStatus::Resolved => { /* ... */ },
    WorkflowStatus::Suppressed => { /* ... */ },
    other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
    _ => { /* ... */ },
}

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

New

Notified

Resolved

Suppressed

Unknown(UnknownVariantValue)

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

Implementations

impl WorkflowStatus

pub fn as_str(&self) -> &str

Returns the &str value of the enum member.

Examples found in repository

src/model.rs (line 9536)

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

src/json_ser.rs (line 1012)

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

pub fn serialize_structure_crate_model_aws_security_finding_filters(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsSecurityFindingFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_210) = &input.product_arn {
        let mut array_211 = object.key("ProductArn").start_array();
        for item_212 in var_210 {
            {
                #[allow(unused_mut)]
                let mut object_213 = array_211.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_213,
                    item_212,
                )?;
                object_213.finish();
            }
        }
        array_211.finish();
    }
    if let Some(var_214) = &input.aws_account_id {
        let mut array_215 = object.key("AwsAccountId").start_array();
        for item_216 in var_214 {
            {
                #[allow(unused_mut)]
                let mut object_217 = array_215.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_217,
                    item_216,
                )?;
                object_217.finish();
            }
        }
        array_215.finish();
    }
    if let Some(var_218) = &input.id {
        let mut array_219 = object.key("Id").start_array();
        for item_220 in var_218 {
            {
                #[allow(unused_mut)]
                let mut object_221 = array_219.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_221,
                    item_220,
                )?;
                object_221.finish();
            }
        }
        array_219.finish();
    }
    if let Some(var_222) = &input.generator_id {
        let mut array_223 = object.key("GeneratorId").start_array();
        for item_224 in var_222 {
            {
                #[allow(unused_mut)]
                let mut object_225 = array_223.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_225,
                    item_224,
                )?;
                object_225.finish();
            }
        }
        array_223.finish();
    }
    if let Some(var_226) = &input.region {
        let mut array_227 = object.key("Region").start_array();
        for item_228 in var_226 {
            {
                #[allow(unused_mut)]
                let mut object_229 = array_227.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_229,
                    item_228,
                )?;
                object_229.finish();
            }
        }
        array_227.finish();
    }
    if let Some(var_230) = &input.r#type {
        let mut array_231 = object.key("Type").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_string_filter(
                    &mut object_233,
                    item_232,
                )?;
                object_233.finish();
            }
        }
        array_231.finish();
    }
    if let Some(var_234) = &input.first_observed_at {
        let mut array_235 = object.key("FirstObservedAt").start_array();
        for item_236 in var_234 {
            {
                #[allow(unused_mut)]
                let mut object_237 = array_235.value().start_object();
                crate::json_ser::serialize_structure_crate_model_date_filter(
                    &mut object_237,
                    item_236,
                )?;
                object_237.finish();
            }
        }
        array_235.finish();
    }
    if let Some(var_238) = &input.last_observed_at {
        let mut array_239 = object.key("LastObservedAt").start_array();
        for item_240 in var_238 {
            {
                #[allow(unused_mut)]
                let mut object_241 = array_239.value().start_object();
                crate::json_ser::serialize_structure_crate_model_date_filter(
                    &mut object_241,
                    item_240,
                )?;
                object_241.finish();
            }
        }
        array_239.finish();
    }
    if let Some(var_242) = &input.created_at {
        let mut array_243 = object.key("CreatedAt").start_array();
        for item_244 in var_242 {
            {
                #[allow(unused_mut)]
                let mut object_245 = array_243.value().start_object();
                crate::json_ser::serialize_structure_crate_model_date_filter(
                    &mut object_245,
                    item_244,
                )?;
                object_245.finish();
            }
        }
        array_243.finish();
    }
    if let Some(var_246) = &input.updated_at {
        let mut array_247 = object.key("UpdatedAt").start_array();
        for item_248 in var_246 {
            {
                #[allow(unused_mut)]
                let mut object_249 = array_247.value().start_object();
                crate::json_ser::serialize_structure_crate_model_date_filter(
                    &mut object_249,
                    item_248,
                )?;
                object_249.finish();
            }
        }
        array_247.finish();
    }
    if let Some(var_250) = &input.severity_product {
        let mut array_251 = object.key("SeverityProduct").start_array();
        for item_252 in var_250 {
            {
                #[allow(unused_mut)]
                let mut object_253 = array_251.value().start_object();
                crate::json_ser::serialize_structure_crate_model_number_filter(
                    &mut object_253,
                    item_252,
                )?;
                object_253.finish();
            }
        }
        array_251.finish();
    }
    if let Some(var_254) = &input.severity_normalized {
        let mut array_255 = object.key("SeverityNormalized").start_array();
        for item_256 in var_254 {
            {
                #[allow(unused_mut)]
                let mut object_257 = array_255.value().start_object();
                crate::json_ser::serialize_structure_crate_model_number_filter(
                    &mut object_257,
                    item_256,
                )?;
                object_257.finish();
            }
        }
        array_255.finish();
    }
    if let Some(var_258) = &input.severity_label {
        let mut array_259 = object.key("SeverityLabel").start_array();
        for item_260 in var_258 {
            {
                #[allow(unused_mut)]
                let mut object_261 = array_259.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_261,
                    item_260,
                )?;
                object_261.finish();
            }
        }
        array_259.finish();
    }
    if let Some(var_262) = &input.confidence {
        let mut array_263 = object.key("Confidence").start_array();
        for item_264 in var_262 {
            {
                #[allow(unused_mut)]
                let mut object_265 = array_263.value().start_object();
                crate::json_ser::serialize_structure_crate_model_number_filter(
                    &mut object_265,
                    item_264,
                )?;
                object_265.finish();
            }
        }
        array_263.finish();
    }
    if let Some(var_266) = &input.criticality {
        let mut array_267 = object.key("Criticality").start_array();
        for item_268 in var_266 {
            {
                #[allow(unused_mut)]
                let mut object_269 = array_267.value().start_object();
                crate::json_ser::serialize_structure_crate_model_number_filter(
                    &mut object_269,
                    item_268,
                )?;
                object_269.finish();
            }
        }
        array_267.finish();
    }
    if let Some(var_270) = &input.title {
        let mut array_271 = object.key("Title").start_array();
        for item_272 in var_270 {
            {
                #[allow(unused_mut)]
                let mut object_273 = array_271.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_273,
                    item_272,
                )?;
                object_273.finish();
            }
        }
        array_271.finish();
    }
    if let Some(var_274) = &input.description {
        let mut array_275 = object.key("Description").start_array();
        for item_276 in var_274 {
            {
                #[allow(unused_mut)]
                let mut object_277 = array_275.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_277,
                    item_276,
                )?;
                object_277.finish();
            }
        }
        array_275.finish();
    }
    if let Some(var_278) = &input.recommendation_text {
        let mut array_279 = object.key("RecommendationText").start_array();
        for item_280 in var_278 {
            {
                #[allow(unused_mut)]
                let mut object_281 = array_279.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_281,
                    item_280,
                )?;
                object_281.finish();
            }
        }
        array_279.finish();
    }
    if let Some(var_282) = &input.source_url {
        let mut array_283 = object.key("SourceUrl").start_array();
        for item_284 in var_282 {
            {
                #[allow(unused_mut)]
                let mut object_285 = array_283.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_285,
                    item_284,
                )?;
                object_285.finish();
            }
        }
        array_283.finish();
    }
    if let Some(var_286) = &input.product_fields {
        let mut array_287 = object.key("ProductFields").start_array();
        for item_288 in var_286 {
            {
                #[allow(unused_mut)]
                let mut object_289 = array_287.value().start_object();
                crate::json_ser::serialize_structure_crate_model_map_filter(
                    &mut object_289,
                    item_288,
                )?;
                object_289.finish();
            }
        }
        array_287.finish();
    }
    if let Some(var_290) = &input.product_name {
        let mut array_291 = object.key("ProductName").start_array();
        for item_292 in var_290 {
            {
                #[allow(unused_mut)]
                let mut object_293 = array_291.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_293,
                    item_292,
                )?;
                object_293.finish();
            }
        }
        array_291.finish();
    }
    if let Some(var_294) = &input.company_name {
        let mut array_295 = object.key("CompanyName").start_array();
        for item_296 in var_294 {
            {
                #[allow(unused_mut)]
                let mut object_297 = array_295.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_297,
                    item_296,
                )?;
                object_297.finish();
            }
        }
        array_295.finish();
    }
    if let Some(var_298) = &input.user_defined_fields {
        let mut array_299 = object.key("UserDefinedFields").start_array();
        for item_300 in var_298 {
            {
                #[allow(unused_mut)]
                let mut object_301 = array_299.value().start_object();
                crate::json_ser::serialize_structure_crate_model_map_filter(
                    &mut object_301,
                    item_300,
                )?;
                object_301.finish();
            }
        }
        array_299.finish();
    }
    if let Some(var_302) = &input.malware_name {
        let mut array_303 = object.key("MalwareName").start_array();
        for item_304 in var_302 {
            {
                #[allow(unused_mut)]
                let mut object_305 = array_303.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_305,
                    item_304,
                )?;
                object_305.finish();
            }
        }
        array_303.finish();
    }
    if let Some(var_306) = &input.malware_type {
        let mut array_307 = object.key("MalwareType").start_array();
        for item_308 in var_306 {
            {
                #[allow(unused_mut)]
                let mut object_309 = array_307.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_309,
                    item_308,
                )?;
                object_309.finish();
            }
        }
        array_307.finish();
    }
    if let Some(var_310) = &input.malware_path {
        let mut array_311 = object.key("MalwarePath").start_array();
        for item_312 in var_310 {
            {
                #[allow(unused_mut)]
                let mut object_313 = array_311.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_313,
                    item_312,
                )?;
                object_313.finish();
            }
        }
        array_311.finish();
    }
    if let Some(var_314) = &input.malware_state {
        let mut array_315 = object.key("MalwareState").start_array();
        for item_316 in var_314 {
            {
                #[allow(unused_mut)]
                let mut object_317 = array_315.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_317,
                    item_316,
                )?;
                object_317.finish();
            }
        }
        array_315.finish();
    }
    if let Some(var_318) = &input.network_direction {
        let mut array_319 = object.key("NetworkDirection").start_array();
        for item_320 in var_318 {
            {
                #[allow(unused_mut)]
                let mut object_321 = array_319.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_321,
                    item_320,
                )?;
                object_321.finish();
            }
        }
        array_319.finish();
    }
    if let Some(var_322) = &input.network_protocol {
        let mut array_323 = object.key("NetworkProtocol").start_array();
        for item_324 in var_322 {
            {
                #[allow(unused_mut)]
                let mut object_325 = array_323.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_325,
                    item_324,
                )?;
                object_325.finish();
            }
        }
        array_323.finish();
    }
    if let Some(var_326) = &input.network_source_ip_v4 {
        let mut array_327 = object.key("NetworkSourceIpV4").start_array();
        for item_328 in var_326 {
            {
                #[allow(unused_mut)]
                let mut object_329 = array_327.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ip_filter(
                    &mut object_329,
                    item_328,
                )?;
                object_329.finish();
            }
        }
        array_327.finish();
    }
    if let Some(var_330) = &input.network_source_ip_v6 {
        let mut array_331 = object.key("NetworkSourceIpV6").start_array();
        for item_332 in var_330 {
            {
                #[allow(unused_mut)]
                let mut object_333 = array_331.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ip_filter(
                    &mut object_333,
                    item_332,
                )?;
                object_333.finish();
            }
        }
        array_331.finish();
    }
    if let Some(var_334) = &input.network_source_port {
        let mut array_335 = object.key("NetworkSourcePort").start_array();
        for item_336 in var_334 {
            {
                #[allow(unused_mut)]
                let mut object_337 = array_335.value().start_object();
                crate::json_ser::serialize_structure_crate_model_number_filter(
                    &mut object_337,
                    item_336,
                )?;
                object_337.finish();
            }
        }
        array_335.finish();
    }
    if let Some(var_338) = &input.network_source_domain {
        let mut array_339 = object.key("NetworkSourceDomain").start_array();
        for item_340 in var_338 {
            {
                #[allow(unused_mut)]
                let mut object_341 = array_339.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_341,
                    item_340,
                )?;
                object_341.finish();
            }
        }
        array_339.finish();
    }
    if let Some(var_342) = &input.network_source_mac {
        let mut array_343 = object.key("NetworkSourceMac").start_array();
        for item_344 in var_342 {
            {
                #[allow(unused_mut)]
                let mut object_345 = array_343.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_345,
                    item_344,
                )?;
                object_345.finish();
            }
        }
        array_343.finish();
    }
    if let Some(var_346) = &input.network_destination_ip_v4 {
        let mut array_347 = object.key("NetworkDestinationIpV4").start_array();
        for item_348 in var_346 {
            {
                #[allow(unused_mut)]
                let mut object_349 = array_347.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ip_filter(
                    &mut object_349,
                    item_348,
                )?;
                object_349.finish();
            }
        }
        array_347.finish();
    }
    if let Some(var_350) = &input.network_destination_ip_v6 {
        let mut array_351 = object.key("NetworkDestinationIpV6").start_array();
        for item_352 in var_350 {
            {
                #[allow(unused_mut)]
                let mut object_353 = array_351.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ip_filter(
                    &mut object_353,
                    item_352,
                )?;
                object_353.finish();
            }
        }
        array_351.finish();
    }
    if let Some(var_354) = &input.network_destination_port {
        let mut array_355 = object.key("NetworkDestinationPort").start_array();
        for item_356 in var_354 {
            {
                #[allow(unused_mut)]
                let mut object_357 = array_355.value().start_object();
                crate::json_ser::serialize_structure_crate_model_number_filter(
                    &mut object_357,
                    item_356,
                )?;
                object_357.finish();
            }
        }
        array_355.finish();
    }
    if let Some(var_358) = &input.network_destination_domain {
        let mut array_359 = object.key("NetworkDestinationDomain").start_array();
        for item_360 in var_358 {
            {
                #[allow(unused_mut)]
                let mut object_361 = array_359.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_361,
                    item_360,
                )?;
                object_361.finish();
            }
        }
        array_359.finish();
    }
    if let Some(var_362) = &input.process_name {
        let mut array_363 = object.key("ProcessName").start_array();
        for item_364 in var_362 {
            {
                #[allow(unused_mut)]
                let mut object_365 = array_363.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_365,
                    item_364,
                )?;
                object_365.finish();
            }
        }
        array_363.finish();
    }
    if let Some(var_366) = &input.process_path {
        let mut array_367 = object.key("ProcessPath").start_array();
        for item_368 in var_366 {
            {
                #[allow(unused_mut)]
                let mut object_369 = array_367.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_369,
                    item_368,
                )?;
                object_369.finish();
            }
        }
        array_367.finish();
    }
    if let Some(var_370) = &input.process_pid {
        let mut array_371 = object.key("ProcessPid").start_array();
        for item_372 in var_370 {
            {
                #[allow(unused_mut)]
                let mut object_373 = array_371.value().start_object();
                crate::json_ser::serialize_structure_crate_model_number_filter(
                    &mut object_373,
                    item_372,
                )?;
                object_373.finish();
            }
        }
        array_371.finish();
    }
    if let Some(var_374) = &input.process_parent_pid {
        let mut array_375 = object.key("ProcessParentPid").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_number_filter(
                    &mut object_377,
                    item_376,
                )?;
                object_377.finish();
            }
        }
        array_375.finish();
    }
    if let Some(var_378) = &input.process_launched_at {
        let mut array_379 = object.key("ProcessLaunchedAt").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_date_filter(
                    &mut object_381,
                    item_380,
                )?;
                object_381.finish();
            }
        }
        array_379.finish();
    }
    if let Some(var_382) = &input.process_terminated_at {
        let mut array_383 = object.key("ProcessTerminatedAt").start_array();
        for item_384 in var_382 {
            {
                #[allow(unused_mut)]
                let mut object_385 = array_383.value().start_object();
                crate::json_ser::serialize_structure_crate_model_date_filter(
                    &mut object_385,
                    item_384,
                )?;
                object_385.finish();
            }
        }
        array_383.finish();
    }
    if let Some(var_386) = &input.threat_intel_indicator_type {
        let mut array_387 = object.key("ThreatIntelIndicatorType").start_array();
        for item_388 in var_386 {
            {
                #[allow(unused_mut)]
                let mut object_389 = array_387.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_389,
                    item_388,
                )?;
                object_389.finish();
            }
        }
        array_387.finish();
    }
    if let Some(var_390) = &input.threat_intel_indicator_value {
        let mut array_391 = object.key("ThreatIntelIndicatorValue").start_array();
        for item_392 in var_390 {
            {
                #[allow(unused_mut)]
                let mut object_393 = array_391.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_393,
                    item_392,
                )?;
                object_393.finish();
            }
        }
        array_391.finish();
    }
    if let Some(var_394) = &input.threat_intel_indicator_category {
        let mut array_395 = object.key("ThreatIntelIndicatorCategory").start_array();
        for item_396 in var_394 {
            {
                #[allow(unused_mut)]
                let mut object_397 = array_395.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_397,
                    item_396,
                )?;
                object_397.finish();
            }
        }
        array_395.finish();
    }
    if let Some(var_398) = &input.threat_intel_indicator_last_observed_at {
        let mut array_399 = object
            .key("ThreatIntelIndicatorLastObservedAt")
            .start_array();
        for item_400 in var_398 {
            {
                #[allow(unused_mut)]
                let mut object_401 = array_399.value().start_object();
                crate::json_ser::serialize_structure_crate_model_date_filter(
                    &mut object_401,
                    item_400,
                )?;
                object_401.finish();
            }
        }
        array_399.finish();
    }
    if let Some(var_402) = &input.threat_intel_indicator_source {
        let mut array_403 = object.key("ThreatIntelIndicatorSource").start_array();
        for item_404 in var_402 {
            {
                #[allow(unused_mut)]
                let mut object_405 = array_403.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_405,
                    item_404,
                )?;
                object_405.finish();
            }
        }
        array_403.finish();
    }
    if let Some(var_406) = &input.threat_intel_indicator_source_url {
        let mut array_407 = object.key("ThreatIntelIndicatorSourceUrl").start_array();
        for item_408 in var_406 {
            {
                #[allow(unused_mut)]
                let mut object_409 = array_407.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_409,
                    item_408,
                )?;
                object_409.finish();
            }
        }
        array_407.finish();
    }
    if let Some(var_410) = &input.resource_type {
        let mut array_411 = object.key("ResourceType").start_array();
        for item_412 in var_410 {
            {
                #[allow(unused_mut)]
                let mut object_413 = array_411.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_413,
                    item_412,
                )?;
                object_413.finish();
            }
        }
        array_411.finish();
    }
    if let Some(var_414) = &input.resource_id {
        let mut array_415 = object.key("ResourceId").start_array();
        for item_416 in var_414 {
            {
                #[allow(unused_mut)]
                let mut object_417 = array_415.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_417,
                    item_416,
                )?;
                object_417.finish();
            }
        }
        array_415.finish();
    }
    if let Some(var_418) = &input.resource_partition {
        let mut array_419 = object.key("ResourcePartition").start_array();
        for item_420 in var_418 {
            {
                #[allow(unused_mut)]
                let mut object_421 = array_419.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_421,
                    item_420,
                )?;
                object_421.finish();
            }
        }
        array_419.finish();
    }
    if let Some(var_422) = &input.resource_region {
        let mut array_423 = object.key("ResourceRegion").start_array();
        for item_424 in var_422 {
            {
                #[allow(unused_mut)]
                let mut object_425 = array_423.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_425,
                    item_424,
                )?;
                object_425.finish();
            }
        }
        array_423.finish();
    }
    if let Some(var_426) = &input.resource_tags {
        let mut array_427 = object.key("ResourceTags").start_array();
        for item_428 in var_426 {
            {
                #[allow(unused_mut)]
                let mut object_429 = array_427.value().start_object();
                crate::json_ser::serialize_structure_crate_model_map_filter(
                    &mut object_429,
                    item_428,
                )?;
                object_429.finish();
            }
        }
        array_427.finish();
    }
    if let Some(var_430) = &input.resource_aws_ec2_instance_type {
        let mut array_431 = object.key("ResourceAwsEc2InstanceType").start_array();
        for item_432 in var_430 {
            {
                #[allow(unused_mut)]
                let mut object_433 = array_431.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_433,
                    item_432,
                )?;
                object_433.finish();
            }
        }
        array_431.finish();
    }
    if let Some(var_434) = &input.resource_aws_ec2_instance_image_id {
        let mut array_435 = object.key("ResourceAwsEc2InstanceImageId").start_array();
        for item_436 in var_434 {
            {
                #[allow(unused_mut)]
                let mut object_437 = array_435.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_437,
                    item_436,
                )?;
                object_437.finish();
            }
        }
        array_435.finish();
    }
    if let Some(var_438) = &input.resource_aws_ec2_instance_ip_v4_addresses {
        let mut array_439 = object
            .key("ResourceAwsEc2InstanceIpV4Addresses")
            .start_array();
        for item_440 in var_438 {
            {
                #[allow(unused_mut)]
                let mut object_441 = array_439.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ip_filter(
                    &mut object_441,
                    item_440,
                )?;
                object_441.finish();
            }
        }
        array_439.finish();
    }
    if let Some(var_442) = &input.resource_aws_ec2_instance_ip_v6_addresses {
        let mut array_443 = object
            .key("ResourceAwsEc2InstanceIpV6Addresses")
            .start_array();
        for item_444 in var_442 {
            {
                #[allow(unused_mut)]
                let mut object_445 = array_443.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ip_filter(
                    &mut object_445,
                    item_444,
                )?;
                object_445.finish();
            }
        }
        array_443.finish();
    }
    if let Some(var_446) = &input.resource_aws_ec2_instance_key_name {
        let mut array_447 = object.key("ResourceAwsEc2InstanceKeyName").start_array();
        for item_448 in var_446 {
            {
                #[allow(unused_mut)]
                let mut object_449 = array_447.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_449,
                    item_448,
                )?;
                object_449.finish();
            }
        }
        array_447.finish();
    }
    if let Some(var_450) = &input.resource_aws_ec2_instance_iam_instance_profile_arn {
        let mut array_451 = object
            .key("ResourceAwsEc2InstanceIamInstanceProfileArn")
            .start_array();
        for item_452 in var_450 {
            {
                #[allow(unused_mut)]
                let mut object_453 = array_451.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_453,
                    item_452,
                )?;
                object_453.finish();
            }
        }
        array_451.finish();
    }
    if let Some(var_454) = &input.resource_aws_ec2_instance_vpc_id {
        let mut array_455 = object.key("ResourceAwsEc2InstanceVpcId").start_array();
        for item_456 in var_454 {
            {
                #[allow(unused_mut)]
                let mut object_457 = array_455.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_457,
                    item_456,
                )?;
                object_457.finish();
            }
        }
        array_455.finish();
    }
    if let Some(var_458) = &input.resource_aws_ec2_instance_subnet_id {
        let mut array_459 = object.key("ResourceAwsEc2InstanceSubnetId").start_array();
        for item_460 in var_458 {
            {
                #[allow(unused_mut)]
                let mut object_461 = array_459.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_461,
                    item_460,
                )?;
                object_461.finish();
            }
        }
        array_459.finish();
    }
    if let Some(var_462) = &input.resource_aws_ec2_instance_launched_at {
        let mut array_463 = object.key("ResourceAwsEc2InstanceLaunchedAt").start_array();
        for item_464 in var_462 {
            {
                #[allow(unused_mut)]
                let mut object_465 = array_463.value().start_object();
                crate::json_ser::serialize_structure_crate_model_date_filter(
                    &mut object_465,
                    item_464,
                )?;
                object_465.finish();
            }
        }
        array_463.finish();
    }
    if let Some(var_466) = &input.resource_aws_s3_bucket_owner_id {
        let mut array_467 = object.key("ResourceAwsS3BucketOwnerId").start_array();
        for item_468 in var_466 {
            {
                #[allow(unused_mut)]
                let mut object_469 = array_467.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_469,
                    item_468,
                )?;
                object_469.finish();
            }
        }
        array_467.finish();
    }
    if let Some(var_470) = &input.resource_aws_s3_bucket_owner_name {
        let mut array_471 = object.key("ResourceAwsS3BucketOwnerName").start_array();
        for item_472 in var_470 {
            {
                #[allow(unused_mut)]
                let mut object_473 = array_471.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_473,
                    item_472,
                )?;
                object_473.finish();
            }
        }
        array_471.finish();
    }
    if let Some(var_474) = &input.resource_aws_iam_access_key_user_name {
        let mut array_475 = object.key("ResourceAwsIamAccessKeyUserName").start_array();
        for item_476 in var_474 {
            {
                #[allow(unused_mut)]
                let mut object_477 = array_475.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_477,
                    item_476,
                )?;
                object_477.finish();
            }
        }
        array_475.finish();
    }
    if let Some(var_478) = &input.resource_aws_iam_access_key_principal_name {
        let mut array_479 = object
            .key("ResourceAwsIamAccessKeyPrincipalName")
            .start_array();
        for item_480 in var_478 {
            {
                #[allow(unused_mut)]
                let mut object_481 = array_479.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_481,
                    item_480,
                )?;
                object_481.finish();
            }
        }
        array_479.finish();
    }
    if let Some(var_482) = &input.resource_aws_iam_access_key_status {
        let mut array_483 = object.key("ResourceAwsIamAccessKeyStatus").start_array();
        for item_484 in var_482 {
            {
                #[allow(unused_mut)]
                let mut object_485 = array_483.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_485,
                    item_484,
                )?;
                object_485.finish();
            }
        }
        array_483.finish();
    }
    if let Some(var_486) = &input.resource_aws_iam_access_key_created_at {
        let mut array_487 = object.key("ResourceAwsIamAccessKeyCreatedAt").start_array();
        for item_488 in var_486 {
            {
                #[allow(unused_mut)]
                let mut object_489 = array_487.value().start_object();
                crate::json_ser::serialize_structure_crate_model_date_filter(
                    &mut object_489,
                    item_488,
                )?;
                object_489.finish();
            }
        }
        array_487.finish();
    }
    if let Some(var_490) = &input.resource_aws_iam_user_user_name {
        let mut array_491 = object.key("ResourceAwsIamUserUserName").start_array();
        for item_492 in var_490 {
            {
                #[allow(unused_mut)]
                let mut object_493 = array_491.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_493,
                    item_492,
                )?;
                object_493.finish();
            }
        }
        array_491.finish();
    }
    if let Some(var_494) = &input.resource_container_name {
        let mut array_495 = object.key("ResourceContainerName").start_array();
        for item_496 in var_494 {
            {
                #[allow(unused_mut)]
                let mut object_497 = array_495.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_497,
                    item_496,
                )?;
                object_497.finish();
            }
        }
        array_495.finish();
    }
    if let Some(var_498) = &input.resource_container_image_id {
        let mut array_499 = object.key("ResourceContainerImageId").start_array();
        for item_500 in var_498 {
            {
                #[allow(unused_mut)]
                let mut object_501 = array_499.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_501,
                    item_500,
                )?;
                object_501.finish();
            }
        }
        array_499.finish();
    }
    if let Some(var_502) = &input.resource_container_image_name {
        let mut array_503 = object.key("ResourceContainerImageName").start_array();
        for item_504 in var_502 {
            {
                #[allow(unused_mut)]
                let mut object_505 = array_503.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_505,
                    item_504,
                )?;
                object_505.finish();
            }
        }
        array_503.finish();
    }
    if let Some(var_506) = &input.resource_container_launched_at {
        let mut array_507 = object.key("ResourceContainerLaunchedAt").start_array();
        for item_508 in var_506 {
            {
                #[allow(unused_mut)]
                let mut object_509 = array_507.value().start_object();
                crate::json_ser::serialize_structure_crate_model_date_filter(
                    &mut object_509,
                    item_508,
                )?;
                object_509.finish();
            }
        }
        array_507.finish();
    }
    if let Some(var_510) = &input.resource_details_other {
        let mut array_511 = object.key("ResourceDetailsOther").start_array();
        for item_512 in var_510 {
            {
                #[allow(unused_mut)]
                let mut object_513 = array_511.value().start_object();
                crate::json_ser::serialize_structure_crate_model_map_filter(
                    &mut object_513,
                    item_512,
                )?;
                object_513.finish();
            }
        }
        array_511.finish();
    }
    if let Some(var_514) = &input.compliance_status {
        let mut array_515 = object.key("ComplianceStatus").start_array();
        for item_516 in var_514 {
            {
                #[allow(unused_mut)]
                let mut object_517 = array_515.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_517,
                    item_516,
                )?;
                object_517.finish();
            }
        }
        array_515.finish();
    }
    if let Some(var_518) = &input.verification_state {
        let mut array_519 = object.key("VerificationState").start_array();
        for item_520 in var_518 {
            {
                #[allow(unused_mut)]
                let mut object_521 = array_519.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_521,
                    item_520,
                )?;
                object_521.finish();
            }
        }
        array_519.finish();
    }
    if let Some(var_522) = &input.workflow_state {
        let mut array_523 = object.key("WorkflowState").start_array();
        for item_524 in var_522 {
            {
                #[allow(unused_mut)]
                let mut object_525 = array_523.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_525,
                    item_524,
                )?;
                object_525.finish();
            }
        }
        array_523.finish();
    }
    if let Some(var_526) = &input.workflow_status {
        let mut array_527 = object.key("WorkflowStatus").start_array();
        for item_528 in var_526 {
            {
                #[allow(unused_mut)]
                let mut object_529 = array_527.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_529,
                    item_528,
                )?;
                object_529.finish();
            }
        }
        array_527.finish();
    }
    if let Some(var_530) = &input.record_state {
        let mut array_531 = object.key("RecordState").start_array();
        for item_532 in var_530 {
            {
                #[allow(unused_mut)]
                let mut object_533 = array_531.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_533,
                    item_532,
                )?;
                object_533.finish();
            }
        }
        array_531.finish();
    }
    if let Some(var_534) = &input.related_findings_product_arn {
        let mut array_535 = object.key("RelatedFindingsProductArn").start_array();
        for item_536 in var_534 {
            {
                #[allow(unused_mut)]
                let mut object_537 = array_535.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_537,
                    item_536,
                )?;
                object_537.finish();
            }
        }
        array_535.finish();
    }
    if let Some(var_538) = &input.related_findings_id {
        let mut array_539 = object.key("RelatedFindingsId").start_array();
        for item_540 in var_538 {
            {
                #[allow(unused_mut)]
                let mut object_541 = array_539.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_541,
                    item_540,
                )?;
                object_541.finish();
            }
        }
        array_539.finish();
    }
    if let Some(var_542) = &input.note_text {
        let mut array_543 = object.key("NoteText").start_array();
        for item_544 in var_542 {
            {
                #[allow(unused_mut)]
                let mut object_545 = array_543.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_545,
                    item_544,
                )?;
                object_545.finish();
            }
        }
        array_543.finish();
    }
    if let Some(var_546) = &input.note_updated_at {
        let mut array_547 = object.key("NoteUpdatedAt").start_array();
        for item_548 in var_546 {
            {
                #[allow(unused_mut)]
                let mut object_549 = array_547.value().start_object();
                crate::json_ser::serialize_structure_crate_model_date_filter(
                    &mut object_549,
                    item_548,
                )?;
                object_549.finish();
            }
        }
        array_547.finish();
    }
    if let Some(var_550) = &input.note_updated_by {
        let mut array_551 = object.key("NoteUpdatedBy").start_array();
        for item_552 in var_550 {
            {
                #[allow(unused_mut)]
                let mut object_553 = array_551.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_553,
                    item_552,
                )?;
                object_553.finish();
            }
        }
        array_551.finish();
    }
    if let Some(var_554) = &input.keyword {
        let mut array_555 = object.key("Keyword").start_array();
        for item_556 in var_554 {
            {
                #[allow(unused_mut)]
                let mut object_557 = array_555.value().start_object();
                crate::json_ser::serialize_structure_crate_model_keyword_filter(
                    &mut object_557,
                    item_556,
                )?;
                object_557.finish();
            }
        }
        array_555.finish();
    }
    if let Some(var_558) = &input.finding_provider_fields_confidence {
        let mut array_559 = object.key("FindingProviderFieldsConfidence").start_array();
        for item_560 in var_558 {
            {
                #[allow(unused_mut)]
                let mut object_561 = array_559.value().start_object();
                crate::json_ser::serialize_structure_crate_model_number_filter(
                    &mut object_561,
                    item_560,
                )?;
                object_561.finish();
            }
        }
        array_559.finish();
    }
    if let Some(var_562) = &input.finding_provider_fields_criticality {
        let mut array_563 = object.key("FindingProviderFieldsCriticality").start_array();
        for item_564 in var_562 {
            {
                #[allow(unused_mut)]
                let mut object_565 = array_563.value().start_object();
                crate::json_ser::serialize_structure_crate_model_number_filter(
                    &mut object_565,
                    item_564,
                )?;
                object_565.finish();
            }
        }
        array_563.finish();
    }
    if let Some(var_566) = &input.finding_provider_fields_related_findings_id {
        let mut array_567 = object
            .key("FindingProviderFieldsRelatedFindingsId")
            .start_array();
        for item_568 in var_566 {
            {
                #[allow(unused_mut)]
                let mut object_569 = array_567.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_569,
                    item_568,
                )?;
                object_569.finish();
            }
        }
        array_567.finish();
    }
    if let Some(var_570) = &input.finding_provider_fields_related_findings_product_arn {
        let mut array_571 = object
            .key("FindingProviderFieldsRelatedFindingsProductArn")
            .start_array();
        for item_572 in var_570 {
            {
                #[allow(unused_mut)]
                let mut object_573 = array_571.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_573,
                    item_572,
                )?;
                object_573.finish();
            }
        }
        array_571.finish();
    }
    if let Some(var_574) = &input.finding_provider_fields_severity_label {
        let mut array_575 = object
            .key("FindingProviderFieldsSeverityLabel")
            .start_array();
        for item_576 in var_574 {
            {
                #[allow(unused_mut)]
                let mut object_577 = array_575.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_577,
                    item_576,
                )?;
                object_577.finish();
            }
        }
        array_575.finish();
    }
    if let Some(var_578) = &input.finding_provider_fields_severity_original {
        let mut array_579 = object
            .key("FindingProviderFieldsSeverityOriginal")
            .start_array();
        for item_580 in var_578 {
            {
                #[allow(unused_mut)]
                let mut object_581 = array_579.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_581,
                    item_580,
                )?;
                object_581.finish();
            }
        }
        array_579.finish();
    }
    if let Some(var_582) = &input.finding_provider_fields_types {
        let mut array_583 = object.key("FindingProviderFieldsTypes").start_array();
        for item_584 in var_582 {
            {
                #[allow(unused_mut)]
                let mut object_585 = array_583.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_585,
                    item_584,
                )?;
                object_585.finish();
            }
        }
        array_583.finish();
    }
    if let Some(var_586) = &input.sample {
        let mut array_587 = object.key("Sample").start_array();
        for item_588 in var_586 {
            {
                #[allow(unused_mut)]
                let mut object_589 = array_587.value().start_object();
                crate::json_ser::serialize_structure_crate_model_boolean_filter(
                    &mut object_589,
                    item_588,
                )?;
                object_589.finish();
            }
        }
        array_587.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_account_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AccountDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_590) = &input.account_id {
        object.key("AccountId").string(var_590.as_str());
    }
    if let Some(var_591) = &input.email {
        object.key("Email").string(var_591.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_sort_criterion(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::SortCriterion,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_592) = &input.field {
        object.key("Field").string(var_592.as_str());
    }
    if let Some(var_593) = &input.sort_order {
        object.key("SortOrder").string(var_593.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_severity(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Severity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if input.product != 0.0 {
        object.key("Product").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.product).into()),
        );
    }
    if let Some(var_594) = &input.label {
        object.key("Label").string(var_594.as_str());
    }
    if input.normalized != 0 {
        object.key("Normalized").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.normalized).into()),
        );
    }
    if let Some(var_595) = &input.original {
        object.key("Original").string(var_595.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_remediation(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Remediation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_596) = &input.recommendation {
        #[allow(unused_mut)]
        let mut object_597 = object.key("Recommendation").start_object();
        crate::json_ser::serialize_structure_crate_model_recommendation(&mut object_597, var_596)?;
        object_597.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_malware(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Malware,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_598) = &input.name {
        object.key("Name").string(var_598.as_str());
    }
    if let Some(var_599) = &input.r#type {
        object.key("Type").string(var_599.as_str());
    }
    if let Some(var_600) = &input.path {
        object.key("Path").string(var_600.as_str());
    }
    if let Some(var_601) = &input.state {
        object.key("State").string(var_601.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_network(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Network,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_602) = &input.direction {
        object.key("Direction").string(var_602.as_str());
    }
    if let Some(var_603) = &input.protocol {
        object.key("Protocol").string(var_603.as_str());
    }
    if let Some(var_604) = &input.open_port_range {
        #[allow(unused_mut)]
        let mut object_605 = object.key("OpenPortRange").start_object();
        crate::json_ser::serialize_structure_crate_model_port_range(&mut object_605, var_604)?;
        object_605.finish();
    }
    if let Some(var_606) = &input.source_ip_v4 {
        object.key("SourceIpV4").string(var_606.as_str());
    }
    if let Some(var_607) = &input.source_ip_v6 {
        object.key("SourceIpV6").string(var_607.as_str());
    }
    if input.source_port != 0 {
        object.key("SourcePort").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.source_port).into()),
        );
    }
    if let Some(var_608) = &input.source_domain {
        object.key("SourceDomain").string(var_608.as_str());
    }
    if let Some(var_609) = &input.source_mac {
        object.key("SourceMac").string(var_609.as_str());
    }
    if let Some(var_610) = &input.destination_ip_v4 {
        object.key("DestinationIpV4").string(var_610.as_str());
    }
    if let Some(var_611) = &input.destination_ip_v6 {
        object.key("DestinationIpV6").string(var_611.as_str());
    }
    if input.destination_port != 0 {
        object.key("DestinationPort").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.destination_port).into()),
        );
    }
    if let Some(var_612) = &input.destination_domain {
        object.key("DestinationDomain").string(var_612.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_network_path_component(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::NetworkPathComponent,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_613) = &input.component_id {
        object.key("ComponentId").string(var_613.as_str());
    }
    if let Some(var_614) = &input.component_type {
        object.key("ComponentType").string(var_614.as_str());
    }
    if let Some(var_615) = &input.egress {
        #[allow(unused_mut)]
        let mut object_616 = object.key("Egress").start_object();
        crate::json_ser::serialize_structure_crate_model_network_header(&mut object_616, var_615)?;
        object_616.finish();
    }
    if let Some(var_617) = &input.ingress {
        #[allow(unused_mut)]
        let mut object_618 = object.key("Ingress").start_object();
        crate::json_ser::serialize_structure_crate_model_network_header(&mut object_618, var_617)?;
        object_618.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_process_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ProcessDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_619) = &input.name {
        object.key("Name").string(var_619.as_str());
    }
    if let Some(var_620) = &input.path {
        object.key("Path").string(var_620.as_str());
    }
    if input.pid != 0 {
        object.key("Pid").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.pid).into()),
        );
    }
    if input.parent_pid != 0 {
        object.key("ParentPid").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.parent_pid).into()),
        );
    }
    if let Some(var_621) = &input.launched_at {
        object.key("LaunchedAt").string(var_621.as_str());
    }
    if let Some(var_622) = &input.terminated_at {
        object.key("TerminatedAt").string(var_622.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_threat(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Threat,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_623) = &input.name {
        object.key("Name").string(var_623.as_str());
    }
    if let Some(var_624) = &input.severity {
        object.key("Severity").string(var_624.as_str());
    }
    if input.item_count != 0 {
        object.key("ItemCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.item_count).into()),
        );
    }
    if let Some(var_625) = &input.file_paths {
        let mut array_626 = object.key("FilePaths").start_array();
        for item_627 in var_625 {
            {
                #[allow(unused_mut)]
                let mut object_628 = array_626.value().start_object();
                crate::json_ser::serialize_structure_crate_model_file_paths(
                    &mut object_628,
                    item_627,
                )?;
                object_628.finish();
            }
        }
        array_626.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_threat_intel_indicator(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ThreatIntelIndicator,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_629) = &input.r#type {
        object.key("Type").string(var_629.as_str());
    }
    if let Some(var_630) = &input.value {
        object.key("Value").string(var_630.as_str());
    }
    if let Some(var_631) = &input.category {
        object.key("Category").string(var_631.as_str());
    }
    if let Some(var_632) = &input.last_observed_at {
        object.key("LastObservedAt").string(var_632.as_str());
    }
    if let Some(var_633) = &input.source {
        object.key("Source").string(var_633.as_str());
    }
    if let Some(var_634) = &input.source_url {
        object.key("SourceUrl").string(var_634.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_resource(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Resource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_635) = &input.r#type {
        object.key("Type").string(var_635.as_str());
    }
    if let Some(var_636) = &input.id {
        object.key("Id").string(var_636.as_str());
    }
    if let Some(var_637) = &input.partition {
        object.key("Partition").string(var_637.as_str());
    }
    if let Some(var_638) = &input.region {
        object.key("Region").string(var_638.as_str());
    }
    if let Some(var_639) = &input.resource_role {
        object.key("ResourceRole").string(var_639.as_str());
    }
    if let Some(var_640) = &input.tags {
        #[allow(unused_mut)]
        let mut object_641 = object.key("Tags").start_object();
        for (key_642, value_643) in var_640 {
            {
                object_641.key(key_642.as_str()).string(value_643.as_str());
            }
        }
        object_641.finish();
    }
    if let Some(var_644) = &input.data_classification {
        #[allow(unused_mut)]
        let mut object_645 = object.key("DataClassification").start_object();
        crate::json_ser::serialize_structure_crate_model_data_classification_details(
            &mut object_645,
            var_644,
        )?;
        object_645.finish();
    }
    if let Some(var_646) = &input.details {
        #[allow(unused_mut)]
        let mut object_647 = object.key("Details").start_object();
        crate::json_ser::serialize_structure_crate_model_resource_details(
            &mut object_647,
            var_646,
        )?;
        object_647.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_compliance(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Compliance,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_648) = &input.status {
        object.key("Status").string(var_648.as_str());
    }
    if let Some(var_649) = &input.related_requirements {
        let mut array_650 = object.key("RelatedRequirements").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.status_reasons {
        let mut array_653 = object.key("StatusReasons").start_array();
        for item_654 in var_652 {
            {
                #[allow(unused_mut)]
                let mut object_655 = array_653.value().start_object();
                crate::json_ser::serialize_structure_crate_model_status_reason(
                    &mut object_655,
                    item_654,
                )?;
                object_655.finish();
            }
        }
        array_653.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_workflow(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Workflow,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_656) = &input.status {
        object.key("Status").string(var_656.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 WorkflowStatus

fn as_ref(&self) -> &str

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

impl Clone for WorkflowStatus

fn clone(&self) -> WorkflowStatus

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for WorkflowStatus

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

Formats the value using the given formatter.

impl From<&str> for WorkflowStatus

fn from(s: &str) -> Self

Converts to this type from the input type.

impl FromStr for WorkflowStatus

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 WorkflowStatus

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 WorkflowStatus

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

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

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

impl StructuralEq for WorkflowStatus

impl StructuralPartialEq for WorkflowStatus