Enum aws_sdk_ssm::model::DocumentFormat

#[non_exhaustive]
pub enum DocumentFormat {
    Json,
    Text,
    Yaml,
    Unknown(UnknownVariantValue),
}

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

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

Json

Text

Yaml

Unknown(UnknownVariantValue)

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

Implementations

impl DocumentFormat

pub fn as_str(&self) -> &str

Returns the &str value of the enum member.

Examples found in repository

src/model.rs (line 5229)

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

src/json_ser.rs (line 352)

pub fn serialize_structure_crate_input_create_document_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateDocumentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_77) = &input.content {
        object.key("Content").string(var_77.as_str());
    }
    if let Some(var_78) = &input.requires {
        let mut array_79 = object.key("Requires").start_array();
        for item_80 in var_78 {
            {
                #[allow(unused_mut)]
                let mut object_81 = array_79.value().start_object();
                crate::json_ser::serialize_structure_crate_model_document_requires(
                    &mut object_81,
                    item_80,
                )?;
                object_81.finish();
            }
        }
        array_79.finish();
    }
    if let Some(var_82) = &input.attachments {
        let mut array_83 = object.key("Attachments").start_array();
        for item_84 in var_82 {
            {
                #[allow(unused_mut)]
                let mut object_85 = array_83.value().start_object();
                crate::json_ser::serialize_structure_crate_model_attachments_source(
                    &mut object_85,
                    item_84,
                )?;
                object_85.finish();
            }
        }
        array_83.finish();
    }
    if let Some(var_86) = &input.name {
        object.key("Name").string(var_86.as_str());
    }
    if let Some(var_87) = &input.display_name {
        object.key("DisplayName").string(var_87.as_str());
    }
    if let Some(var_88) = &input.version_name {
        object.key("VersionName").string(var_88.as_str());
    }
    if let Some(var_89) = &input.document_type {
        object.key("DocumentType").string(var_89.as_str());
    }
    if let Some(var_90) = &input.document_format {
        object.key("DocumentFormat").string(var_90.as_str());
    }
    if let Some(var_91) = &input.target_type {
        object.key("TargetType").string(var_91.as_str());
    }
    if let Some(var_92) = &input.tags {
        let mut array_93 = object.key("Tags").start_array();
        for item_94 in var_92 {
            {
                #[allow(unused_mut)]
                let mut object_95 = array_93.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_95, item_94)?;
                object_95.finish();
            }
        }
        array_93.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_maintenance_window_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateMaintenanceWindowInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_96) = &input.name {
        object.key("Name").string(var_96.as_str());
    }
    if let Some(var_97) = &input.description {
        object.key("Description").string(var_97.as_str());
    }
    if let Some(var_98) = &input.start_date {
        object.key("StartDate").string(var_98.as_str());
    }
    if let Some(var_99) = &input.end_date {
        object.key("EndDate").string(var_99.as_str());
    }
    if let Some(var_100) = &input.schedule {
        object.key("Schedule").string(var_100.as_str());
    }
    if let Some(var_101) = &input.schedule_timezone {
        object.key("ScheduleTimezone").string(var_101.as_str());
    }
    if let Some(var_102) = &input.schedule_offset {
        object.key("ScheduleOffset").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_102).into()),
        );
    }
    {
        object.key("Duration").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.duration).into()),
        );
    }
    {
        object.key("Cutoff").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.cutoff).into()),
        );
    }
    {
        object
            .key("AllowUnassociatedTargets")
            .boolean(input.allow_unassociated_targets);
    }
    if let Some(var_103) = &input.client_token {
        object.key("ClientToken").string(var_103.as_str());
    }
    if let Some(var_104) = &input.tags {
        let mut array_105 = object.key("Tags").start_array();
        for item_106 in var_104 {
            {
                #[allow(unused_mut)]
                let mut object_107 = array_105.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_107, item_106)?;
                object_107.finish();
            }
        }
        array_105.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_ops_item_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateOpsItemInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_108) = &input.description {
        object.key("Description").string(var_108.as_str());
    }
    if let Some(var_109) = &input.ops_item_type {
        object.key("OpsItemType").string(var_109.as_str());
    }
    if let Some(var_110) = &input.operational_data {
        #[allow(unused_mut)]
        let mut object_111 = object.key("OperationalData").start_object();
        for (key_112, value_113) in var_110 {
            {
                #[allow(unused_mut)]
                let mut object_114 = object_111.key(key_112.as_str()).start_object();
                crate::json_ser::serialize_structure_crate_model_ops_item_data_value(
                    &mut object_114,
                    value_113,
                )?;
                object_114.finish();
            }
        }
        object_111.finish();
    }
    if let Some(var_115) = &input.notifications {
        let mut array_116 = object.key("Notifications").start_array();
        for item_117 in var_115 {
            {
                #[allow(unused_mut)]
                let mut object_118 = array_116.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ops_item_notification(
                    &mut object_118,
                    item_117,
                )?;
                object_118.finish();
            }
        }
        array_116.finish();
    }
    if let Some(var_119) = &input.priority {
        object.key("Priority").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_119).into()),
        );
    }
    if let Some(var_120) = &input.related_ops_items {
        let mut array_121 = object.key("RelatedOpsItems").start_array();
        for item_122 in var_120 {
            {
                #[allow(unused_mut)]
                let mut object_123 = array_121.value().start_object();
                crate::json_ser::serialize_structure_crate_model_related_ops_item(
                    &mut object_123,
                    item_122,
                )?;
                object_123.finish();
            }
        }
        array_121.finish();
    }
    if let Some(var_124) = &input.source {
        object.key("Source").string(var_124.as_str());
    }
    if let Some(var_125) = &input.title {
        object.key("Title").string(var_125.as_str());
    }
    if let Some(var_126) = &input.tags {
        let mut array_127 = object.key("Tags").start_array();
        for item_128 in var_126 {
            {
                #[allow(unused_mut)]
                let mut object_129 = array_127.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_129, item_128)?;
                object_129.finish();
            }
        }
        array_127.finish();
    }
    if let Some(var_130) = &input.category {
        object.key("Category").string(var_130.as_str());
    }
    if let Some(var_131) = &input.severity {
        object.key("Severity").string(var_131.as_str());
    }
    if let Some(var_132) = &input.actual_start_time {
        object
            .key("ActualStartTime")
            .date_time(var_132, aws_smithy_types::date_time::Format::EpochSeconds)?;
    }
    if let Some(var_133) = &input.actual_end_time {
        object
            .key("ActualEndTime")
            .date_time(var_133, aws_smithy_types::date_time::Format::EpochSeconds)?;
    }
    if let Some(var_134) = &input.planned_start_time {
        object
            .key("PlannedStartTime")
            .date_time(var_134, aws_smithy_types::date_time::Format::EpochSeconds)?;
    }
    if let Some(var_135) = &input.planned_end_time {
        object
            .key("PlannedEndTime")
            .date_time(var_135, aws_smithy_types::date_time::Format::EpochSeconds)?;
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_ops_metadata_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateOpsMetadataInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_136) = &input.resource_id {
        object.key("ResourceId").string(var_136.as_str());
    }
    if let Some(var_137) = &input.metadata {
        #[allow(unused_mut)]
        let mut object_138 = object.key("Metadata").start_object();
        for (key_139, value_140) in var_137 {
            {
                #[allow(unused_mut)]
                let mut object_141 = object_138.key(key_139.as_str()).start_object();
                crate::json_ser::serialize_structure_crate_model_metadata_value(
                    &mut object_141,
                    value_140,
                )?;
                object_141.finish();
            }
        }
        object_138.finish();
    }
    if let Some(var_142) = &input.tags {
        let mut array_143 = object.key("Tags").start_array();
        for item_144 in var_142 {
            {
                #[allow(unused_mut)]
                let mut object_145 = array_143.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_145, item_144)?;
                object_145.finish();
            }
        }
        array_143.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_patch_baseline_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreatePatchBaselineInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_146) = &input.operating_system {
        object.key("OperatingSystem").string(var_146.as_str());
    }
    if let Some(var_147) = &input.name {
        object.key("Name").string(var_147.as_str());
    }
    if let Some(var_148) = &input.global_filters {
        #[allow(unused_mut)]
        let mut object_149 = object.key("GlobalFilters").start_object();
        crate::json_ser::serialize_structure_crate_model_patch_filter_group(
            &mut object_149,
            var_148,
        )?;
        object_149.finish();
    }
    if let Some(var_150) = &input.approval_rules {
        #[allow(unused_mut)]
        let mut object_151 = object.key("ApprovalRules").start_object();
        crate::json_ser::serialize_structure_crate_model_patch_rule_group(
            &mut object_151,
            var_150,
        )?;
        object_151.finish();
    }
    if let Some(var_152) = &input.approved_patches {
        let mut array_153 = object.key("ApprovedPatches").start_array();
        for item_154 in var_152 {
            {
                array_153.value().string(item_154.as_str());
            }
        }
        array_153.finish();
    }
    if let Some(var_155) = &input.approved_patches_compliance_level {
        object
            .key("ApprovedPatchesComplianceLevel")
            .string(var_155.as_str());
    }
    if let Some(var_156) = &input.approved_patches_enable_non_security {
        object
            .key("ApprovedPatchesEnableNonSecurity")
            .boolean(*var_156);
    }
    if let Some(var_157) = &input.rejected_patches {
        let mut array_158 = object.key("RejectedPatches").start_array();
        for item_159 in var_157 {
            {
                array_158.value().string(item_159.as_str());
            }
        }
        array_158.finish();
    }
    if let Some(var_160) = &input.rejected_patches_action {
        object.key("RejectedPatchesAction").string(var_160.as_str());
    }
    if let Some(var_161) = &input.description {
        object.key("Description").string(var_161.as_str());
    }
    if let Some(var_162) = &input.sources {
        let mut array_163 = object.key("Sources").start_array();
        for item_164 in var_162 {
            {
                #[allow(unused_mut)]
                let mut object_165 = array_163.value().start_object();
                crate::json_ser::serialize_structure_crate_model_patch_source(
                    &mut object_165,
                    item_164,
                )?;
                object_165.finish();
            }
        }
        array_163.finish();
    }
    if let Some(var_166) = &input.client_token {
        object.key("ClientToken").string(var_166.as_str());
    }
    if let Some(var_167) = &input.tags {
        let mut array_168 = object.key("Tags").start_array();
        for item_169 in var_167 {
            {
                #[allow(unused_mut)]
                let mut object_170 = array_168.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_170, item_169)?;
                object_170.finish();
            }
        }
        array_168.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_resource_data_sync_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateResourceDataSyncInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_171) = &input.sync_name {
        object.key("SyncName").string(var_171.as_str());
    }
    if let Some(var_172) = &input.s3_destination {
        #[allow(unused_mut)]
        let mut object_173 = object.key("S3Destination").start_object();
        crate::json_ser::serialize_structure_crate_model_resource_data_sync_s3_destination(
            &mut object_173,
            var_172,
        )?;
        object_173.finish();
    }
    if let Some(var_174) = &input.sync_type {
        object.key("SyncType").string(var_174.as_str());
    }
    if let Some(var_175) = &input.sync_source {
        #[allow(unused_mut)]
        let mut object_176 = object.key("SyncSource").start_object();
        crate::json_ser::serialize_structure_crate_model_resource_data_sync_source(
            &mut object_176,
            var_175,
        )?;
        object_176.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_activation_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteActivationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_177) = &input.activation_id {
        object.key("ActivationId").string(var_177.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_association_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteAssociationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_178) = &input.name {
        object.key("Name").string(var_178.as_str());
    }
    if let Some(var_179) = &input.instance_id {
        object.key("InstanceId").string(var_179.as_str());
    }
    if let Some(var_180) = &input.association_id {
        object.key("AssociationId").string(var_180.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_document_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteDocumentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_181) = &input.name {
        object.key("Name").string(var_181.as_str());
    }
    if let Some(var_182) = &input.document_version {
        object.key("DocumentVersion").string(var_182.as_str());
    }
    if let Some(var_183) = &input.version_name {
        object.key("VersionName").string(var_183.as_str());
    }
    if input.force {
        object.key("Force").boolean(input.force);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_inventory_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteInventoryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_184) = &input.type_name {
        object.key("TypeName").string(var_184.as_str());
    }
    if let Some(var_185) = &input.schema_delete_option {
        object.key("SchemaDeleteOption").string(var_185.as_str());
    }
    if input.dry_run {
        object.key("DryRun").boolean(input.dry_run);
    }
    if let Some(var_186) = &input.client_token {
        object.key("ClientToken").string(var_186.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_maintenance_window_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteMaintenanceWindowInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_187) = &input.window_id {
        object.key("WindowId").string(var_187.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_ops_metadata_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteOpsMetadataInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_188) = &input.ops_metadata_arn {
        object.key("OpsMetadataArn").string(var_188.as_str());
    }
    Ok(())
}

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

pub fn serialize_structure_crate_input_delete_parameters_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteParametersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_190) = &input.names {
        let mut array_191 = object.key("Names").start_array();
        for item_192 in var_190 {
            {
                array_191.value().string(item_192.as_str());
            }
        }
        array_191.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_patch_baseline_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeletePatchBaselineInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_193) = &input.baseline_id {
        object.key("BaselineId").string(var_193.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_resource_data_sync_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteResourceDataSyncInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_194) = &input.sync_name {
        object.key("SyncName").string(var_194.as_str());
    }
    if let Some(var_195) = &input.sync_type {
        object.key("SyncType").string(var_195.as_str());
    }
    Ok(())
}

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

pub fn serialize_structure_crate_input_deregister_patch_baseline_for_patch_group_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeregisterPatchBaselineForPatchGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_197) = &input.baseline_id {
        object.key("BaselineId").string(var_197.as_str());
    }
    if let Some(var_198) = &input.patch_group {
        object.key("PatchGroup").string(var_198.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_deregister_target_from_maintenance_window_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeregisterTargetFromMaintenanceWindowInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_199) = &input.window_id {
        object.key("WindowId").string(var_199.as_str());
    }
    if let Some(var_200) = &input.window_target_id {
        object.key("WindowTargetId").string(var_200.as_str());
    }
    if let Some(var_201) = &input.safe {
        object.key("Safe").boolean(*var_201);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_deregister_task_from_maintenance_window_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeregisterTaskFromMaintenanceWindowInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_202) = &input.window_id {
        object.key("WindowId").string(var_202.as_str());
    }
    if let Some(var_203) = &input.window_task_id {
        object.key("WindowTaskId").string(var_203.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_activations_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeActivationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_204) = &input.filters {
        let mut array_205 = object.key("Filters").start_array();
        for item_206 in var_204 {
            {
                #[allow(unused_mut)]
                let mut object_207 = array_205.value().start_object();
                crate::json_ser::serialize_structure_crate_model_describe_activations_filter(
                    &mut object_207,
                    item_206,
                )?;
                object_207.finish();
            }
        }
        array_205.finish();
    }
    if let Some(var_208) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_208).into()),
        );
    }
    if let Some(var_209) = &input.next_token {
        object.key("NextToken").string(var_209.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_association_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeAssociationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_210) = &input.name {
        object.key("Name").string(var_210.as_str());
    }
    if let Some(var_211) = &input.instance_id {
        object.key("InstanceId").string(var_211.as_str());
    }
    if let Some(var_212) = &input.association_id {
        object.key("AssociationId").string(var_212.as_str());
    }
    if let Some(var_213) = &input.association_version {
        object.key("AssociationVersion").string(var_213.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_association_executions_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeAssociationExecutionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_214) = &input.association_id {
        object.key("AssociationId").string(var_214.as_str());
    }
    if let Some(var_215) = &input.filters {
        let mut array_216 = object.key("Filters").start_array();
        for item_217 in var_215 {
            {
                #[allow(unused_mut)]
                let mut object_218 = array_216.value().start_object();
                crate::json_ser::serialize_structure_crate_model_association_execution_filter(
                    &mut object_218,
                    item_217,
                )?;
                object_218.finish();
            }
        }
        array_216.finish();
    }
    if let Some(var_219) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_219).into()),
        );
    }
    if let Some(var_220) = &input.next_token {
        object.key("NextToken").string(var_220.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_association_execution_targets_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeAssociationExecutionTargetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_221) = &input.association_id {
        object.key("AssociationId").string(var_221.as_str());
    }
    if let Some(var_222) = &input.execution_id {
        object.key("ExecutionId").string(var_222.as_str());
    }
    if let Some(var_223) = &input.filters {
        let mut array_224 = object.key("Filters").start_array();
        for item_225 in var_223 {
            {
                #[allow(unused_mut)]
                let mut object_226 = array_224.value().start_object();
                crate::json_ser::serialize_structure_crate_model_association_execution_targets_filter(&mut object_226, item_225)?;
                object_226.finish();
            }
        }
        array_224.finish();
    }
    if let Some(var_227) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_227).into()),
        );
    }
    if let Some(var_228) = &input.next_token {
        object.key("NextToken").string(var_228.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_automation_executions_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeAutomationExecutionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_229) = &input.filters {
        let mut array_230 = object.key("Filters").start_array();
        for item_231 in var_229 {
            {
                #[allow(unused_mut)]
                let mut object_232 = array_230.value().start_object();
                crate::json_ser::serialize_structure_crate_model_automation_execution_filter(
                    &mut object_232,
                    item_231,
                )?;
                object_232.finish();
            }
        }
        array_230.finish();
    }
    if let Some(var_233) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_233).into()),
        );
    }
    if let Some(var_234) = &input.next_token {
        object.key("NextToken").string(var_234.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_automation_step_executions_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeAutomationStepExecutionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_235) = &input.automation_execution_id {
        object.key("AutomationExecutionId").string(var_235.as_str());
    }
    if let Some(var_236) = &input.filters {
        let mut array_237 = object.key("Filters").start_array();
        for item_238 in var_236 {
            {
                #[allow(unused_mut)]
                let mut object_239 = array_237.value().start_object();
                crate::json_ser::serialize_structure_crate_model_step_execution_filter(
                    &mut object_239,
                    item_238,
                )?;
                object_239.finish();
            }
        }
        array_237.finish();
    }
    if let Some(var_240) = &input.next_token {
        object.key("NextToken").string(var_240.as_str());
    }
    if let Some(var_241) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_241).into()),
        );
    }
    if let Some(var_242) = &input.reverse_order {
        object.key("ReverseOrder").boolean(*var_242);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_available_patches_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeAvailablePatchesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_243) = &input.filters {
        let mut array_244 = object.key("Filters").start_array();
        for item_245 in var_243 {
            {
                #[allow(unused_mut)]
                let mut object_246 = array_244.value().start_object();
                crate::json_ser::serialize_structure_crate_model_patch_orchestrator_filter(
                    &mut object_246,
                    item_245,
                )?;
                object_246.finish();
            }
        }
        array_244.finish();
    }
    if let Some(var_247) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_247).into()),
        );
    }
    if let Some(var_248) = &input.next_token {
        object.key("NextToken").string(var_248.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_document_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeDocumentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_249) = &input.name {
        object.key("Name").string(var_249.as_str());
    }
    if let Some(var_250) = &input.document_version {
        object.key("DocumentVersion").string(var_250.as_str());
    }
    if let Some(var_251) = &input.version_name {
        object.key("VersionName").string(var_251.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_document_permission_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeDocumentPermissionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_252) = &input.name {
        object.key("Name").string(var_252.as_str());
    }
    if let Some(var_253) = &input.permission_type {
        object.key("PermissionType").string(var_253.as_str());
    }
    if let Some(var_254) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_254).into()),
        );
    }
    if let Some(var_255) = &input.next_token {
        object.key("NextToken").string(var_255.as_str());
    }
    Ok(())
}

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

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

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

pub fn serialize_structure_crate_input_describe_instance_information_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeInstanceInformationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_265) = &input.instance_information_filter_list {
        let mut array_266 = object.key("InstanceInformationFilterList").start_array();
        for item_267 in var_265 {
            {
                #[allow(unused_mut)]
                let mut object_268 = array_266.value().start_object();
                crate::json_ser::serialize_structure_crate_model_instance_information_filter(
                    &mut object_268,
                    item_267,
                )?;
                object_268.finish();
            }
        }
        array_266.finish();
    }
    if let Some(var_269) = &input.filters {
        let mut array_270 = object.key("Filters").start_array();
        for item_271 in var_269 {
            {
                #[allow(unused_mut)]
                let mut object_272 = array_270.value().start_object();
                crate::json_ser::serialize_structure_crate_model_instance_information_string_filter(&mut object_272, item_271)?;
                object_272.finish();
            }
        }
        array_270.finish();
    }
    if let Some(var_273) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_273).into()),
        );
    }
    if let Some(var_274) = &input.next_token {
        object.key("NextToken").string(var_274.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_instance_patches_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeInstancePatchesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_275) = &input.instance_id {
        object.key("InstanceId").string(var_275.as_str());
    }
    if let Some(var_276) = &input.filters {
        let mut array_277 = object.key("Filters").start_array();
        for item_278 in var_276 {
            {
                #[allow(unused_mut)]
                let mut object_279 = array_277.value().start_object();
                crate::json_ser::serialize_structure_crate_model_patch_orchestrator_filter(
                    &mut object_279,
                    item_278,
                )?;
                object_279.finish();
            }
        }
        array_277.finish();
    }
    if let Some(var_280) = &input.next_token {
        object.key("NextToken").string(var_280.as_str());
    }
    if let Some(var_281) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_281).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_instance_patch_states_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeInstancePatchStatesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_282) = &input.instance_ids {
        let mut array_283 = object.key("InstanceIds").start_array();
        for item_284 in var_282 {
            {
                array_283.value().string(item_284.as_str());
            }
        }
        array_283.finish();
    }
    if let Some(var_285) = &input.next_token {
        object.key("NextToken").string(var_285.as_str());
    }
    if let Some(var_286) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_286).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_instance_patch_states_for_patch_group_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeInstancePatchStatesForPatchGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_287) = &input.patch_group {
        object.key("PatchGroup").string(var_287.as_str());
    }
    if let Some(var_288) = &input.filters {
        let mut array_289 = object.key("Filters").start_array();
        for item_290 in var_288 {
            {
                #[allow(unused_mut)]
                let mut object_291 = array_289.value().start_object();
                crate::json_ser::serialize_structure_crate_model_instance_patch_state_filter(
                    &mut object_291,
                    item_290,
                )?;
                object_291.finish();
            }
        }
        array_289.finish();
    }
    if let Some(var_292) = &input.next_token {
        object.key("NextToken").string(var_292.as_str());
    }
    if let Some(var_293) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_293).into()),
        );
    }
    Ok(())
}

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

pub fn serialize_structure_crate_input_describe_maintenance_window_executions_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeMaintenanceWindowExecutionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_297) = &input.window_id {
        object.key("WindowId").string(var_297.as_str());
    }
    if let Some(var_298) = &input.filters {
        let mut array_299 = object.key("Filters").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_maintenance_window_filter(
                    &mut object_301,
                    item_300,
                )?;
                object_301.finish();
            }
        }
        array_299.finish();
    }
    if let Some(var_302) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_302).into()),
        );
    }
    if let Some(var_303) = &input.next_token {
        object.key("NextToken").string(var_303.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_maintenance_window_execution_task_invocations_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeMaintenanceWindowExecutionTaskInvocationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_304) = &input.window_execution_id {
        object.key("WindowExecutionId").string(var_304.as_str());
    }
    if let Some(var_305) = &input.task_id {
        object.key("TaskId").string(var_305.as_str());
    }
    if let Some(var_306) = &input.filters {
        let mut array_307 = object.key("Filters").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_maintenance_window_filter(
                    &mut object_309,
                    item_308,
                )?;
                object_309.finish();
            }
        }
        array_307.finish();
    }
    if let Some(var_310) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_310).into()),
        );
    }
    if let Some(var_311) = &input.next_token {
        object.key("NextToken").string(var_311.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_maintenance_window_execution_tasks_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeMaintenanceWindowExecutionTasksInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_312) = &input.window_execution_id {
        object.key("WindowExecutionId").string(var_312.as_str());
    }
    if let Some(var_313) = &input.filters {
        let mut array_314 = object.key("Filters").start_array();
        for item_315 in var_313 {
            {
                #[allow(unused_mut)]
                let mut object_316 = array_314.value().start_object();
                crate::json_ser::serialize_structure_crate_model_maintenance_window_filter(
                    &mut object_316,
                    item_315,
                )?;
                object_316.finish();
            }
        }
        array_314.finish();
    }
    if let Some(var_317) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_317).into()),
        );
    }
    if let Some(var_318) = &input.next_token {
        object.key("NextToken").string(var_318.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_maintenance_windows_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeMaintenanceWindowsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_319) = &input.filters {
        let mut array_320 = object.key("Filters").start_array();
        for item_321 in var_319 {
            {
                #[allow(unused_mut)]
                let mut object_322 = array_320.value().start_object();
                crate::json_ser::serialize_structure_crate_model_maintenance_window_filter(
                    &mut object_322,
                    item_321,
                )?;
                object_322.finish();
            }
        }
        array_320.finish();
    }
    if let Some(var_323) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_323).into()),
        );
    }
    if let Some(var_324) = &input.next_token {
        object.key("NextToken").string(var_324.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_maintenance_window_schedule_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeMaintenanceWindowScheduleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_325) = &input.window_id {
        object.key("WindowId").string(var_325.as_str());
    }
    if let Some(var_326) = &input.targets {
        let mut array_327 = object.key("Targets").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_target(&mut object_329, item_328)?;
                object_329.finish();
            }
        }
        array_327.finish();
    }
    if let Some(var_330) = &input.resource_type {
        object.key("ResourceType").string(var_330.as_str());
    }
    if let Some(var_331) = &input.filters {
        let mut array_332 = object.key("Filters").start_array();
        for item_333 in var_331 {
            {
                #[allow(unused_mut)]
                let mut object_334 = array_332.value().start_object();
                crate::json_ser::serialize_structure_crate_model_patch_orchestrator_filter(
                    &mut object_334,
                    item_333,
                )?;
                object_334.finish();
            }
        }
        array_332.finish();
    }
    if let Some(var_335) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_335).into()),
        );
    }
    if let Some(var_336) = &input.next_token {
        object.key("NextToken").string(var_336.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_maintenance_windows_for_target_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeMaintenanceWindowsForTargetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_337) = &input.targets {
        let mut array_338 = object.key("Targets").start_array();
        for item_339 in var_337 {
            {
                #[allow(unused_mut)]
                let mut object_340 = array_338.value().start_object();
                crate::json_ser::serialize_structure_crate_model_target(&mut object_340, item_339)?;
                object_340.finish();
            }
        }
        array_338.finish();
    }
    if let Some(var_341) = &input.resource_type {
        object.key("ResourceType").string(var_341.as_str());
    }
    if let Some(var_342) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_342).into()),
        );
    }
    if let Some(var_343) = &input.next_token {
        object.key("NextToken").string(var_343.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_maintenance_window_targets_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeMaintenanceWindowTargetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_344) = &input.window_id {
        object.key("WindowId").string(var_344.as_str());
    }
    if let Some(var_345) = &input.filters {
        let mut array_346 = object.key("Filters").start_array();
        for item_347 in var_345 {
            {
                #[allow(unused_mut)]
                let mut object_348 = array_346.value().start_object();
                crate::json_ser::serialize_structure_crate_model_maintenance_window_filter(
                    &mut object_348,
                    item_347,
                )?;
                object_348.finish();
            }
        }
        array_346.finish();
    }
    if let Some(var_349) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_349).into()),
        );
    }
    if let Some(var_350) = &input.next_token {
        object.key("NextToken").string(var_350.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_maintenance_window_tasks_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeMaintenanceWindowTasksInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_351) = &input.window_id {
        object.key("WindowId").string(var_351.as_str());
    }
    if let Some(var_352) = &input.filters {
        let mut array_353 = object.key("Filters").start_array();
        for item_354 in var_352 {
            {
                #[allow(unused_mut)]
                let mut object_355 = array_353.value().start_object();
                crate::json_ser::serialize_structure_crate_model_maintenance_window_filter(
                    &mut object_355,
                    item_354,
                )?;
                object_355.finish();
            }
        }
        array_353.finish();
    }
    if let Some(var_356) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_356).into()),
        );
    }
    if let Some(var_357) = &input.next_token {
        object.key("NextToken").string(var_357.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_ops_items_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeOpsItemsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_358) = &input.ops_item_filters {
        let mut array_359 = object.key("OpsItemFilters").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_ops_item_filter(
                    &mut object_361,
                    item_360,
                )?;
                object_361.finish();
            }
        }
        array_359.finish();
    }
    if let Some(var_362) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_362).into()),
        );
    }
    if let Some(var_363) = &input.next_token {
        object.key("NextToken").string(var_363.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_parameters_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeParametersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_364) = &input.filters {
        let mut array_365 = object.key("Filters").start_array();
        for item_366 in var_364 {
            {
                #[allow(unused_mut)]
                let mut object_367 = array_365.value().start_object();
                crate::json_ser::serialize_structure_crate_model_parameters_filter(
                    &mut object_367,
                    item_366,
                )?;
                object_367.finish();
            }
        }
        array_365.finish();
    }
    if let Some(var_368) = &input.parameter_filters {
        let mut array_369 = object.key("ParameterFilters").start_array();
        for item_370 in var_368 {
            {
                #[allow(unused_mut)]
                let mut object_371 = array_369.value().start_object();
                crate::json_ser::serialize_structure_crate_model_parameter_string_filter(
                    &mut object_371,
                    item_370,
                )?;
                object_371.finish();
            }
        }
        array_369.finish();
    }
    if let Some(var_372) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_372).into()),
        );
    }
    if let Some(var_373) = &input.next_token {
        object.key("NextToken").string(var_373.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_patch_baselines_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribePatchBaselinesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_374) = &input.filters {
        let mut array_375 = object.key("Filters").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_patch_orchestrator_filter(
                    &mut object_377,
                    item_376,
                )?;
                object_377.finish();
            }
        }
        array_375.finish();
    }
    if let Some(var_378) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_378).into()),
        );
    }
    if let Some(var_379) = &input.next_token {
        object.key("NextToken").string(var_379.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_patch_groups_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribePatchGroupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_380) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_380).into()),
        );
    }
    if let Some(var_381) = &input.filters {
        let mut array_382 = object.key("Filters").start_array();
        for item_383 in var_381 {
            {
                #[allow(unused_mut)]
                let mut object_384 = array_382.value().start_object();
                crate::json_ser::serialize_structure_crate_model_patch_orchestrator_filter(
                    &mut object_384,
                    item_383,
                )?;
                object_384.finish();
            }
        }
        array_382.finish();
    }
    if let Some(var_385) = &input.next_token {
        object.key("NextToken").string(var_385.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_patch_group_state_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribePatchGroupStateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_386) = &input.patch_group {
        object.key("PatchGroup").string(var_386.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_patch_properties_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribePatchPropertiesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_387) = &input.operating_system {
        object.key("OperatingSystem").string(var_387.as_str());
    }
    if let Some(var_388) = &input.property {
        object.key("Property").string(var_388.as_str());
    }
    if let Some(var_389) = &input.patch_set {
        object.key("PatchSet").string(var_389.as_str());
    }
    if let Some(var_390) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_390).into()),
        );
    }
    if let Some(var_391) = &input.next_token {
        object.key("NextToken").string(var_391.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_sessions_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeSessionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_392) = &input.state {
        object.key("State").string(var_392.as_str());
    }
    if let Some(var_393) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_393).into()),
        );
    }
    if let Some(var_394) = &input.next_token {
        object.key("NextToken").string(var_394.as_str());
    }
    if let Some(var_395) = &input.filters {
        let mut array_396 = object.key("Filters").start_array();
        for item_397 in var_395 {
            {
                #[allow(unused_mut)]
                let mut object_398 = array_396.value().start_object();
                crate::json_ser::serialize_structure_crate_model_session_filter(
                    &mut object_398,
                    item_397,
                )?;
                object_398.finish();
            }
        }
        array_396.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_disassociate_ops_item_related_item_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DisassociateOpsItemRelatedItemInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_399) = &input.ops_item_id {
        object.key("OpsItemId").string(var_399.as_str());
    }
    if let Some(var_400) = &input.association_id {
        object.key("AssociationId").string(var_400.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_automation_execution_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetAutomationExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_401) = &input.automation_execution_id {
        object.key("AutomationExecutionId").string(var_401.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_calendar_state_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetCalendarStateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_402) = &input.calendar_names {
        let mut array_403 = object.key("CalendarNames").start_array();
        for item_404 in var_402 {
            {
                array_403.value().string(item_404.as_str());
            }
        }
        array_403.finish();
    }
    if let Some(var_405) = &input.at_time {
        object.key("AtTime").string(var_405.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_command_invocation_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetCommandInvocationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_406) = &input.command_id {
        object.key("CommandId").string(var_406.as_str());
    }
    if let Some(var_407) = &input.instance_id {
        object.key("InstanceId").string(var_407.as_str());
    }
    if let Some(var_408) = &input.plugin_name {
        object.key("PluginName").string(var_408.as_str());
    }
    Ok(())
}

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

pub fn serialize_structure_crate_input_get_default_patch_baseline_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetDefaultPatchBaselineInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_410) = &input.operating_system {
        object.key("OperatingSystem").string(var_410.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_deployable_patch_snapshot_for_instance_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetDeployablePatchSnapshotForInstanceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_411) = &input.instance_id {
        object.key("InstanceId").string(var_411.as_str());
    }
    if let Some(var_412) = &input.snapshot_id {
        object.key("SnapshotId").string(var_412.as_str());
    }
    if let Some(var_413) = &input.baseline_override {
        #[allow(unused_mut)]
        let mut object_414 = object.key("BaselineOverride").start_object();
        crate::json_ser::serialize_structure_crate_model_baseline_override(
            &mut object_414,
            var_413,
        )?;
        object_414.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_document_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetDocumentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_415) = &input.name {
        object.key("Name").string(var_415.as_str());
    }
    if let Some(var_416) = &input.version_name {
        object.key("VersionName").string(var_416.as_str());
    }
    if let Some(var_417) = &input.document_version {
        object.key("DocumentVersion").string(var_417.as_str());
    }
    if let Some(var_418) = &input.document_format {
        object.key("DocumentFormat").string(var_418.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_inventory_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetInventoryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_419) = &input.filters {
        let mut array_420 = object.key("Filters").start_array();
        for item_421 in var_419 {
            {
                #[allow(unused_mut)]
                let mut object_422 = array_420.value().start_object();
                crate::json_ser::serialize_structure_crate_model_inventory_filter(
                    &mut object_422,
                    item_421,
                )?;
                object_422.finish();
            }
        }
        array_420.finish();
    }
    if let Some(var_423) = &input.aggregators {
        let mut array_424 = object.key("Aggregators").start_array();
        for item_425 in var_423 {
            {
                #[allow(unused_mut)]
                let mut object_426 = array_424.value().start_object();
                crate::json_ser::serialize_structure_crate_model_inventory_aggregator(
                    &mut object_426,
                    item_425,
                )?;
                object_426.finish();
            }
        }
        array_424.finish();
    }
    if let Some(var_427) = &input.result_attributes {
        let mut array_428 = object.key("ResultAttributes").start_array();
        for item_429 in var_427 {
            {
                #[allow(unused_mut)]
                let mut object_430 = array_428.value().start_object();
                crate::json_ser::serialize_structure_crate_model_result_attribute(
                    &mut object_430,
                    item_429,
                )?;
                object_430.finish();
            }
        }
        array_428.finish();
    }
    if let Some(var_431) = &input.next_token {
        object.key("NextToken").string(var_431.as_str());
    }
    if let Some(var_432) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_432).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_inventory_schema_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetInventorySchemaInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_433) = &input.type_name {
        object.key("TypeName").string(var_433.as_str());
    }
    if let Some(var_434) = &input.next_token {
        object.key("NextToken").string(var_434.as_str());
    }
    if let Some(var_435) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_435).into()),
        );
    }
    if input.aggregator {
        object.key("Aggregator").boolean(input.aggregator);
    }
    if let Some(var_436) = &input.sub_type {
        object.key("SubType").boolean(*var_436);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_maintenance_window_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetMaintenanceWindowInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_437) = &input.window_id {
        object.key("WindowId").string(var_437.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_maintenance_window_execution_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetMaintenanceWindowExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_438) = &input.window_execution_id {
        object.key("WindowExecutionId").string(var_438.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_maintenance_window_execution_task_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetMaintenanceWindowExecutionTaskInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_439) = &input.window_execution_id {
        object.key("WindowExecutionId").string(var_439.as_str());
    }
    if let Some(var_440) = &input.task_id {
        object.key("TaskId").string(var_440.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_maintenance_window_execution_task_invocation_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetMaintenanceWindowExecutionTaskInvocationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_441) = &input.window_execution_id {
        object.key("WindowExecutionId").string(var_441.as_str());
    }
    if let Some(var_442) = &input.task_id {
        object.key("TaskId").string(var_442.as_str());
    }
    if let Some(var_443) = &input.invocation_id {
        object.key("InvocationId").string(var_443.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_maintenance_window_task_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetMaintenanceWindowTaskInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_444) = &input.window_id {
        object.key("WindowId").string(var_444.as_str());
    }
    if let Some(var_445) = &input.window_task_id {
        object.key("WindowTaskId").string(var_445.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_ops_item_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetOpsItemInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_446) = &input.ops_item_id {
        object.key("OpsItemId").string(var_446.as_str());
    }
    Ok(())
}

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

pub fn serialize_structure_crate_input_get_ops_summary_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetOpsSummaryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_450) = &input.sync_name {
        object.key("SyncName").string(var_450.as_str());
    }
    if let Some(var_451) = &input.filters {
        let mut array_452 = object.key("Filters").start_array();
        for item_453 in var_451 {
            {
                #[allow(unused_mut)]
                let mut object_454 = array_452.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ops_filter(
                    &mut object_454,
                    item_453,
                )?;
                object_454.finish();
            }
        }
        array_452.finish();
    }
    if let Some(var_455) = &input.aggregators {
        let mut array_456 = object.key("Aggregators").start_array();
        for item_457 in var_455 {
            {
                #[allow(unused_mut)]
                let mut object_458 = array_456.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ops_aggregator(
                    &mut object_458,
                    item_457,
                )?;
                object_458.finish();
            }
        }
        array_456.finish();
    }
    if let Some(var_459) = &input.result_attributes {
        let mut array_460 = object.key("ResultAttributes").start_array();
        for item_461 in var_459 {
            {
                #[allow(unused_mut)]
                let mut object_462 = array_460.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ops_result_attribute(
                    &mut object_462,
                    item_461,
                )?;
                object_462.finish();
            }
        }
        array_460.finish();
    }
    if let Some(var_463) = &input.next_token {
        object.key("NextToken").string(var_463.as_str());
    }
    if let Some(var_464) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_464).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_parameter_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetParameterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_465) = &input.name {
        object.key("Name").string(var_465.as_str());
    }
    if let Some(var_466) = &input.with_decryption {
        object.key("WithDecryption").boolean(*var_466);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_parameter_history_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetParameterHistoryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_467) = &input.name {
        object.key("Name").string(var_467.as_str());
    }
    if let Some(var_468) = &input.with_decryption {
        object.key("WithDecryption").boolean(*var_468);
    }
    if let Some(var_469) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_469).into()),
        );
    }
    if let Some(var_470) = &input.next_token {
        object.key("NextToken").string(var_470.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_parameters_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetParametersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_471) = &input.names {
        let mut array_472 = object.key("Names").start_array();
        for item_473 in var_471 {
            {
                array_472.value().string(item_473.as_str());
            }
        }
        array_472.finish();
    }
    if let Some(var_474) = &input.with_decryption {
        object.key("WithDecryption").boolean(*var_474);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_parameters_by_path_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetParametersByPathInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_475) = &input.path {
        object.key("Path").string(var_475.as_str());
    }
    if let Some(var_476) = &input.recursive {
        object.key("Recursive").boolean(*var_476);
    }
    if let Some(var_477) = &input.parameter_filters {
        let mut array_478 = object.key("ParameterFilters").start_array();
        for item_479 in var_477 {
            {
                #[allow(unused_mut)]
                let mut object_480 = array_478.value().start_object();
                crate::json_ser::serialize_structure_crate_model_parameter_string_filter(
                    &mut object_480,
                    item_479,
                )?;
                object_480.finish();
            }
        }
        array_478.finish();
    }
    if let Some(var_481) = &input.with_decryption {
        object.key("WithDecryption").boolean(*var_481);
    }
    if let Some(var_482) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_482).into()),
        );
    }
    if let Some(var_483) = &input.next_token {
        object.key("NextToken").string(var_483.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_patch_baseline_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetPatchBaselineInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_484) = &input.baseline_id {
        object.key("BaselineId").string(var_484.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_patch_baseline_for_patch_group_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetPatchBaselineForPatchGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_485) = &input.patch_group {
        object.key("PatchGroup").string(var_485.as_str());
    }
    if let Some(var_486) = &input.operating_system {
        object.key("OperatingSystem").string(var_486.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_service_setting_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetServiceSettingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_487) = &input.setting_id {
        object.key("SettingId").string(var_487.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_label_parameter_version_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::LabelParameterVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_488) = &input.name {
        object.key("Name").string(var_488.as_str());
    }
    if let Some(var_489) = &input.parameter_version {
        object.key("ParameterVersion").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_489).into()),
        );
    }
    if let Some(var_490) = &input.labels {
        let mut array_491 = object.key("Labels").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_list_associations_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListAssociationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_493) = &input.association_filter_list {
        let mut array_494 = object.key("AssociationFilterList").start_array();
        for item_495 in var_493 {
            {
                #[allow(unused_mut)]
                let mut object_496 = array_494.value().start_object();
                crate::json_ser::serialize_structure_crate_model_association_filter(
                    &mut object_496,
                    item_495,
                )?;
                object_496.finish();
            }
        }
        array_494.finish();
    }
    if let Some(var_497) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_497).into()),
        );
    }
    if let Some(var_498) = &input.next_token {
        object.key("NextToken").string(var_498.as_str());
    }
    Ok(())
}

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

pub fn serialize_structure_crate_input_list_command_invocations_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListCommandInvocationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_502) = &input.command_id {
        object.key("CommandId").string(var_502.as_str());
    }
    if let Some(var_503) = &input.instance_id {
        object.key("InstanceId").string(var_503.as_str());
    }
    if let Some(var_504) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_504).into()),
        );
    }
    if let Some(var_505) = &input.next_token {
        object.key("NextToken").string(var_505.as_str());
    }
    if let Some(var_506) = &input.filters {
        let mut array_507 = object.key("Filters").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_command_filter(
                    &mut object_509,
                    item_508,
                )?;
                object_509.finish();
            }
        }
        array_507.finish();
    }
    if input.details {
        object.key("Details").boolean(input.details);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_commands_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListCommandsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_510) = &input.command_id {
        object.key("CommandId").string(var_510.as_str());
    }
    if let Some(var_511) = &input.instance_id {
        object.key("InstanceId").string(var_511.as_str());
    }
    if let Some(var_512) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_512).into()),
        );
    }
    if let Some(var_513) = &input.next_token {
        object.key("NextToken").string(var_513.as_str());
    }
    if let Some(var_514) = &input.filters {
        let mut array_515 = object.key("Filters").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_command_filter(
                    &mut object_517,
                    item_516,
                )?;
                object_517.finish();
            }
        }
        array_515.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_compliance_items_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListComplianceItemsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_518) = &input.filters {
        let mut array_519 = object.key("Filters").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_compliance_string_filter(
                    &mut object_521,
                    item_520,
                )?;
                object_521.finish();
            }
        }
        array_519.finish();
    }
    if let Some(var_522) = &input.resource_ids {
        let mut array_523 = object.key("ResourceIds").start_array();
        for item_524 in var_522 {
            {
                array_523.value().string(item_524.as_str());
            }
        }
        array_523.finish();
    }
    if let Some(var_525) = &input.resource_types {
        let mut array_526 = object.key("ResourceTypes").start_array();
        for item_527 in var_525 {
            {
                array_526.value().string(item_527.as_str());
            }
        }
        array_526.finish();
    }
    if let Some(var_528) = &input.next_token {
        object.key("NextToken").string(var_528.as_str());
    }
    if let Some(var_529) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_529).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_compliance_summaries_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListComplianceSummariesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_530) = &input.filters {
        let mut array_531 = object.key("Filters").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_compliance_string_filter(
                    &mut object_533,
                    item_532,
                )?;
                object_533.finish();
            }
        }
        array_531.finish();
    }
    if let Some(var_534) = &input.next_token {
        object.key("NextToken").string(var_534.as_str());
    }
    if let Some(var_535) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_535).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_document_metadata_history_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListDocumentMetadataHistoryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_536) = &input.name {
        object.key("Name").string(var_536.as_str());
    }
    if let Some(var_537) = &input.document_version {
        object.key("DocumentVersion").string(var_537.as_str());
    }
    if let Some(var_538) = &input.metadata {
        object.key("Metadata").string(var_538.as_str());
    }
    if let Some(var_539) = &input.next_token {
        object.key("NextToken").string(var_539.as_str());
    }
    if let Some(var_540) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_540).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_documents_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListDocumentsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_541) = &input.document_filter_list {
        let mut array_542 = object.key("DocumentFilterList").start_array();
        for item_543 in var_541 {
            {
                #[allow(unused_mut)]
                let mut object_544 = array_542.value().start_object();
                crate::json_ser::serialize_structure_crate_model_document_filter(
                    &mut object_544,
                    item_543,
                )?;
                object_544.finish();
            }
        }
        array_542.finish();
    }
    if let Some(var_545) = &input.filters {
        let mut array_546 = object.key("Filters").start_array();
        for item_547 in var_545 {
            {
                #[allow(unused_mut)]
                let mut object_548 = array_546.value().start_object();
                crate::json_ser::serialize_structure_crate_model_document_key_values_filter(
                    &mut object_548,
                    item_547,
                )?;
                object_548.finish();
            }
        }
        array_546.finish();
    }
    if let Some(var_549) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_549).into()),
        );
    }
    if let Some(var_550) = &input.next_token {
        object.key("NextToken").string(var_550.as_str());
    }
    Ok(())
}

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

pub fn serialize_structure_crate_input_list_inventory_entries_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListInventoryEntriesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_554) = &input.instance_id {
        object.key("InstanceId").string(var_554.as_str());
    }
    if let Some(var_555) = &input.type_name {
        object.key("TypeName").string(var_555.as_str());
    }
    if let Some(var_556) = &input.filters {
        let mut array_557 = object.key("Filters").start_array();
        for item_558 in var_556 {
            {
                #[allow(unused_mut)]
                let mut object_559 = array_557.value().start_object();
                crate::json_ser::serialize_structure_crate_model_inventory_filter(
                    &mut object_559,
                    item_558,
                )?;
                object_559.finish();
            }
        }
        array_557.finish();
    }
    if let Some(var_560) = &input.next_token {
        object.key("NextToken").string(var_560.as_str());
    }
    if let Some(var_561) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_561).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_ops_item_events_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListOpsItemEventsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_562) = &input.filters {
        let mut array_563 = object.key("Filters").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_ops_item_event_filter(
                    &mut object_565,
                    item_564,
                )?;
                object_565.finish();
            }
        }
        array_563.finish();
    }
    if let Some(var_566) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_566).into()),
        );
    }
    if let Some(var_567) = &input.next_token {
        object.key("NextToken").string(var_567.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_ops_item_related_items_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListOpsItemRelatedItemsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_568) = &input.ops_item_id {
        object.key("OpsItemId").string(var_568.as_str());
    }
    if let Some(var_569) = &input.filters {
        let mut array_570 = object.key("Filters").start_array();
        for item_571 in var_569 {
            {
                #[allow(unused_mut)]
                let mut object_572 = array_570.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ops_item_related_items_filter(
                    &mut object_572,
                    item_571,
                )?;
                object_572.finish();
            }
        }
        array_570.finish();
    }
    if let Some(var_573) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_573).into()),
        );
    }
    if let Some(var_574) = &input.next_token {
        object.key("NextToken").string(var_574.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_ops_metadata_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListOpsMetadataInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_575) = &input.filters {
        let mut array_576 = object.key("Filters").start_array();
        for item_577 in var_575 {
            {
                #[allow(unused_mut)]
                let mut object_578 = array_576.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ops_metadata_filter(
                    &mut object_578,
                    item_577,
                )?;
                object_578.finish();
            }
        }
        array_576.finish();
    }
    if let Some(var_579) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_579).into()),
        );
    }
    if let Some(var_580) = &input.next_token {
        object.key("NextToken").string(var_580.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_resource_compliance_summaries_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListResourceComplianceSummariesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_581) = &input.filters {
        let mut array_582 = object.key("Filters").start_array();
        for item_583 in var_581 {
            {
                #[allow(unused_mut)]
                let mut object_584 = array_582.value().start_object();
                crate::json_ser::serialize_structure_crate_model_compliance_string_filter(
                    &mut object_584,
                    item_583,
                )?;
                object_584.finish();
            }
        }
        array_582.finish();
    }
    if let Some(var_585) = &input.next_token {
        object.key("NextToken").string(var_585.as_str());
    }
    if let Some(var_586) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_586).into()),
        );
    }
    Ok(())
}

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

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

pub fn serialize_structure_crate_input_modify_document_permission_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ModifyDocumentPermissionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_592) = &input.name {
        object.key("Name").string(var_592.as_str());
    }
    if let Some(var_593) = &input.permission_type {
        object.key("PermissionType").string(var_593.as_str());
    }
    if let Some(var_594) = &input.account_ids_to_add {
        let mut array_595 = object.key("AccountIdsToAdd").start_array();
        for item_596 in var_594 {
            {
                array_595.value().string(item_596.as_str());
            }
        }
        array_595.finish();
    }
    if let Some(var_597) = &input.account_ids_to_remove {
        let mut array_598 = object.key("AccountIdsToRemove").start_array();
        for item_599 in var_597 {
            {
                array_598.value().string(item_599.as_str());
            }
        }
        array_598.finish();
    }
    if let Some(var_600) = &input.shared_document_version {
        object.key("SharedDocumentVersion").string(var_600.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_compliance_items_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutComplianceItemsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_601) = &input.resource_id {
        object.key("ResourceId").string(var_601.as_str());
    }
    if let Some(var_602) = &input.resource_type {
        object.key("ResourceType").string(var_602.as_str());
    }
    if let Some(var_603) = &input.compliance_type {
        object.key("ComplianceType").string(var_603.as_str());
    }
    if let Some(var_604) = &input.execution_summary {
        #[allow(unused_mut)]
        let mut object_605 = object.key("ExecutionSummary").start_object();
        crate::json_ser::serialize_structure_crate_model_compliance_execution_summary(
            &mut object_605,
            var_604,
        )?;
        object_605.finish();
    }
    if let Some(var_606) = &input.items {
        let mut array_607 = object.key("Items").start_array();
        for item_608 in var_606 {
            {
                #[allow(unused_mut)]
                let mut object_609 = array_607.value().start_object();
                crate::json_ser::serialize_structure_crate_model_compliance_item_entry(
                    &mut object_609,
                    item_608,
                )?;
                object_609.finish();
            }
        }
        array_607.finish();
    }
    if let Some(var_610) = &input.item_content_hash {
        object.key("ItemContentHash").string(var_610.as_str());
    }
    if let Some(var_611) = &input.upload_type {
        object.key("UploadType").string(var_611.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_inventory_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutInventoryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_612) = &input.instance_id {
        object.key("InstanceId").string(var_612.as_str());
    }
    if let Some(var_613) = &input.items {
        let mut array_614 = object.key("Items").start_array();
        for item_615 in var_613 {
            {
                #[allow(unused_mut)]
                let mut object_616 = array_614.value().start_object();
                crate::json_ser::serialize_structure_crate_model_inventory_item(
                    &mut object_616,
                    item_615,
                )?;
                object_616.finish();
            }
        }
        array_614.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_parameter_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutParameterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_617) = &input.name {
        object.key("Name").string(var_617.as_str());
    }
    if let Some(var_618) = &input.description {
        object.key("Description").string(var_618.as_str());
    }
    if let Some(var_619) = &input.value {
        object.key("Value").string(var_619.as_str());
    }
    if let Some(var_620) = &input.r#type {
        object.key("Type").string(var_620.as_str());
    }
    if let Some(var_621) = &input.key_id {
        object.key("KeyId").string(var_621.as_str());
    }
    if let Some(var_622) = &input.overwrite {
        object.key("Overwrite").boolean(*var_622);
    }
    if let Some(var_623) = &input.allowed_pattern {
        object.key("AllowedPattern").string(var_623.as_str());
    }
    if let Some(var_624) = &input.tags {
        let mut array_625 = object.key("Tags").start_array();
        for item_626 in var_624 {
            {
                #[allow(unused_mut)]
                let mut object_627 = array_625.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_627, item_626)?;
                object_627.finish();
            }
        }
        array_625.finish();
    }
    if let Some(var_628) = &input.tier {
        object.key("Tier").string(var_628.as_str());
    }
    if let Some(var_629) = &input.policies {
        object.key("Policies").string(var_629.as_str());
    }
    if let Some(var_630) = &input.data_type {
        object.key("DataType").string(var_630.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_register_default_patch_baseline_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::RegisterDefaultPatchBaselineInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_631) = &input.baseline_id {
        object.key("BaselineId").string(var_631.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_register_patch_baseline_for_patch_group_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::RegisterPatchBaselineForPatchGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_632) = &input.baseline_id {
        object.key("BaselineId").string(var_632.as_str());
    }
    if let Some(var_633) = &input.patch_group {
        object.key("PatchGroup").string(var_633.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_register_target_with_maintenance_window_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::RegisterTargetWithMaintenanceWindowInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_634) = &input.window_id {
        object.key("WindowId").string(var_634.as_str());
    }
    if let Some(var_635) = &input.resource_type {
        object.key("ResourceType").string(var_635.as_str());
    }
    if let Some(var_636) = &input.targets {
        let mut array_637 = object.key("Targets").start_array();
        for item_638 in var_636 {
            {
                #[allow(unused_mut)]
                let mut object_639 = array_637.value().start_object();
                crate::json_ser::serialize_structure_crate_model_target(&mut object_639, item_638)?;
                object_639.finish();
            }
        }
        array_637.finish();
    }
    if let Some(var_640) = &input.owner_information {
        object.key("OwnerInformation").string(var_640.as_str());
    }
    if let Some(var_641) = &input.name {
        object.key("Name").string(var_641.as_str());
    }
    if let Some(var_642) = &input.description {
        object.key("Description").string(var_642.as_str());
    }
    if let Some(var_643) = &input.client_token {
        object.key("ClientToken").string(var_643.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_register_task_with_maintenance_window_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::RegisterTaskWithMaintenanceWindowInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_644) = &input.window_id {
        object.key("WindowId").string(var_644.as_str());
    }
    if let Some(var_645) = &input.targets {
        let mut array_646 = object.key("Targets").start_array();
        for item_647 in var_645 {
            {
                #[allow(unused_mut)]
                let mut object_648 = array_646.value().start_object();
                crate::json_ser::serialize_structure_crate_model_target(&mut object_648, item_647)?;
                object_648.finish();
            }
        }
        array_646.finish();
    }
    if let Some(var_649) = &input.task_arn {
        object.key("TaskArn").string(var_649.as_str());
    }
    if let Some(var_650) = &input.service_role_arn {
        object.key("ServiceRoleArn").string(var_650.as_str());
    }
    if let Some(var_651) = &input.task_type {
        object.key("TaskType").string(var_651.as_str());
    }
    if let Some(var_652) = &input.task_parameters {
        #[allow(unused_mut)]
        let mut object_653 = object.key("TaskParameters").start_object();
        for (key_654, value_655) in var_652 {
            {
                #[allow(unused_mut)]
                let mut object_656 = object_653.key(key_654.as_str()).start_object();
                crate::json_ser::serialize_structure_crate_model_maintenance_window_task_parameter_value_expression(&mut object_656, value_655)?;
                object_656.finish();
            }
        }
        object_653.finish();
    }
    if let Some(var_657) = &input.task_invocation_parameters {
        #[allow(unused_mut)]
        let mut object_658 = object.key("TaskInvocationParameters").start_object();
        crate::json_ser::serialize_structure_crate_model_maintenance_window_task_invocation_parameters(&mut object_658, var_657)?;
        object_658.finish();
    }
    if let Some(var_659) = &input.priority {
        object.key("Priority").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_659).into()),
        );
    }
    if let Some(var_660) = &input.max_concurrency {
        object.key("MaxConcurrency").string(var_660.as_str());
    }
    if let Some(var_661) = &input.max_errors {
        object.key("MaxErrors").string(var_661.as_str());
    }
    if let Some(var_662) = &input.logging_info {
        #[allow(unused_mut)]
        let mut object_663 = object.key("LoggingInfo").start_object();
        crate::json_ser::serialize_structure_crate_model_logging_info(&mut object_663, var_662)?;
        object_663.finish();
    }
    if let Some(var_664) = &input.name {
        object.key("Name").string(var_664.as_str());
    }
    if let Some(var_665) = &input.description {
        object.key("Description").string(var_665.as_str());
    }
    if let Some(var_666) = &input.client_token {
        object.key("ClientToken").string(var_666.as_str());
    }
    if let Some(var_667) = &input.cutoff_behavior {
        object.key("CutoffBehavior").string(var_667.as_str());
    }
    if let Some(var_668) = &input.alarm_configuration {
        #[allow(unused_mut)]
        let mut object_669 = object.key("AlarmConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_alarm_configuration(
            &mut object_669,
            var_668,
        )?;
        object_669.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_remove_tags_from_resource_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::RemoveTagsFromResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_670) = &input.resource_type {
        object.key("ResourceType").string(var_670.as_str());
    }
    if let Some(var_671) = &input.resource_id {
        object.key("ResourceId").string(var_671.as_str());
    }
    if let Some(var_672) = &input.tag_keys {
        let mut array_673 = object.key("TagKeys").start_array();
        for item_674 in var_672 {
            {
                array_673.value().string(item_674.as_str());
            }
        }
        array_673.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_reset_service_setting_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ResetServiceSettingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_675) = &input.setting_id {
        object.key("SettingId").string(var_675.as_str());
    }
    Ok(())
}

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

pub fn serialize_structure_crate_input_send_automation_signal_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::SendAutomationSignalInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_677) = &input.automation_execution_id {
        object.key("AutomationExecutionId").string(var_677.as_str());
    }
    if let Some(var_678) = &input.signal_type {
        object.key("SignalType").string(var_678.as_str());
    }
    if let Some(var_679) = &input.payload {
        #[allow(unused_mut)]
        let mut object_680 = object.key("Payload").start_object();
        for (key_681, value_682) in var_679 {
            {
                let mut array_683 = object_680.key(key_681.as_str()).start_array();
                for item_684 in value_682 {
                    {
                        array_683.value().string(item_684.as_str());
                    }
                }
                array_683.finish();
            }
        }
        object_680.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_send_command_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::SendCommandInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_685) = &input.instance_ids {
        let mut array_686 = object.key("InstanceIds").start_array();
        for item_687 in var_685 {
            {
                array_686.value().string(item_687.as_str());
            }
        }
        array_686.finish();
    }
    if let Some(var_688) = &input.targets {
        let mut array_689 = object.key("Targets").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_target(&mut object_691, item_690)?;
                object_691.finish();
            }
        }
        array_689.finish();
    }
    if let Some(var_692) = &input.document_name {
        object.key("DocumentName").string(var_692.as_str());
    }
    if let Some(var_693) = &input.document_version {
        object.key("DocumentVersion").string(var_693.as_str());
    }
    if let Some(var_694) = &input.document_hash {
        object.key("DocumentHash").string(var_694.as_str());
    }
    if let Some(var_695) = &input.document_hash_type {
        object.key("DocumentHashType").string(var_695.as_str());
    }
    if let Some(var_696) = &input.timeout_seconds {
        object.key("TimeoutSeconds").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_696).into()),
        );
    }
    if let Some(var_697) = &input.comment {
        object.key("Comment").string(var_697.as_str());
    }
    if let Some(var_698) = &input.parameters {
        #[allow(unused_mut)]
        let mut object_699 = object.key("Parameters").start_object();
        for (key_700, value_701) in var_698 {
            {
                let mut array_702 = object_699.key(key_700.as_str()).start_array();
                for item_703 in value_701 {
                    {
                        array_702.value().string(item_703.as_str());
                    }
                }
                array_702.finish();
            }
        }
        object_699.finish();
    }
    if let Some(var_704) = &input.output_s3_region {
        object.key("OutputS3Region").string(var_704.as_str());
    }
    if let Some(var_705) = &input.output_s3_bucket_name {
        object.key("OutputS3BucketName").string(var_705.as_str());
    }
    if let Some(var_706) = &input.output_s3_key_prefix {
        object.key("OutputS3KeyPrefix").string(var_706.as_str());
    }
    if let Some(var_707) = &input.max_concurrency {
        object.key("MaxConcurrency").string(var_707.as_str());
    }
    if let Some(var_708) = &input.max_errors {
        object.key("MaxErrors").string(var_708.as_str());
    }
    if let Some(var_709) = &input.service_role_arn {
        object.key("ServiceRoleArn").string(var_709.as_str());
    }
    if let Some(var_710) = &input.notification_config {
        #[allow(unused_mut)]
        let mut object_711 = object.key("NotificationConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_notification_config(
            &mut object_711,
            var_710,
        )?;
        object_711.finish();
    }
    if let Some(var_712) = &input.cloud_watch_output_config {
        #[allow(unused_mut)]
        let mut object_713 = object.key("CloudWatchOutputConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_cloud_watch_output_config(
            &mut object_713,
            var_712,
        )?;
        object_713.finish();
    }
    if let Some(var_714) = &input.alarm_configuration {
        #[allow(unused_mut)]
        let mut object_715 = object.key("AlarmConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_alarm_configuration(
            &mut object_715,
            var_714,
        )?;
        object_715.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_start_associations_once_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::StartAssociationsOnceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_716) = &input.association_ids {
        let mut array_717 = object.key("AssociationIds").start_array();
        for item_718 in var_716 {
            {
                array_717.value().string(item_718.as_str());
            }
        }
        array_717.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_start_automation_execution_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::StartAutomationExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_719) = &input.document_name {
        object.key("DocumentName").string(var_719.as_str());
    }
    if let Some(var_720) = &input.document_version {
        object.key("DocumentVersion").string(var_720.as_str());
    }
    if let Some(var_721) = &input.parameters {
        #[allow(unused_mut)]
        let mut object_722 = object.key("Parameters").start_object();
        for (key_723, value_724) in var_721 {
            {
                let mut array_725 = object_722.key(key_723.as_str()).start_array();
                for item_726 in value_724 {
                    {
                        array_725.value().string(item_726.as_str());
                    }
                }
                array_725.finish();
            }
        }
        object_722.finish();
    }
    if let Some(var_727) = &input.client_token {
        object.key("ClientToken").string(var_727.as_str());
    }
    if let Some(var_728) = &input.mode {
        object.key("Mode").string(var_728.as_str());
    }
    if let Some(var_729) = &input.target_parameter_name {
        object.key("TargetParameterName").string(var_729.as_str());
    }
    if let Some(var_730) = &input.targets {
        let mut array_731 = object.key("Targets").start_array();
        for item_732 in var_730 {
            {
                #[allow(unused_mut)]
                let mut object_733 = array_731.value().start_object();
                crate::json_ser::serialize_structure_crate_model_target(&mut object_733, item_732)?;
                object_733.finish();
            }
        }
        array_731.finish();
    }
    if let Some(var_734) = &input.target_maps {
        let mut array_735 = object.key("TargetMaps").start_array();
        for item_736 in var_734 {
            {
                #[allow(unused_mut)]
                let mut object_737 = array_735.value().start_object();
                for (key_738, value_739) in item_736 {
                    {
                        let mut array_740 = object_737.key(key_738.as_str()).start_array();
                        for item_741 in value_739 {
                            {
                                array_740.value().string(item_741.as_str());
                            }
                        }
                        array_740.finish();
                    }
                }
                object_737.finish();
            }
        }
        array_735.finish();
    }
    if let Some(var_742) = &input.max_concurrency {
        object.key("MaxConcurrency").string(var_742.as_str());
    }
    if let Some(var_743) = &input.max_errors {
        object.key("MaxErrors").string(var_743.as_str());
    }
    if let Some(var_744) = &input.target_locations {
        let mut array_745 = object.key("TargetLocations").start_array();
        for item_746 in var_744 {
            {
                #[allow(unused_mut)]
                let mut object_747 = array_745.value().start_object();
                crate::json_ser::serialize_structure_crate_model_target_location(
                    &mut object_747,
                    item_746,
                )?;
                object_747.finish();
            }
        }
        array_745.finish();
    }
    if let Some(var_748) = &input.tags {
        let mut array_749 = object.key("Tags").start_array();
        for item_750 in var_748 {
            {
                #[allow(unused_mut)]
                let mut object_751 = array_749.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_751, item_750)?;
                object_751.finish();
            }
        }
        array_749.finish();
    }
    if let Some(var_752) = &input.alarm_configuration {
        #[allow(unused_mut)]
        let mut object_753 = object.key("AlarmConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_alarm_configuration(
            &mut object_753,
            var_752,
        )?;
        object_753.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_start_change_request_execution_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::StartChangeRequestExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_754) = &input.scheduled_time {
        object
            .key("ScheduledTime")
            .date_time(var_754, aws_smithy_types::date_time::Format::EpochSeconds)?;
    }
    if let Some(var_755) = &input.document_name {
        object.key("DocumentName").string(var_755.as_str());
    }
    if let Some(var_756) = &input.document_version {
        object.key("DocumentVersion").string(var_756.as_str());
    }
    if let Some(var_757) = &input.parameters {
        #[allow(unused_mut)]
        let mut object_758 = object.key("Parameters").start_object();
        for (key_759, value_760) in var_757 {
            {
                let mut array_761 = object_758.key(key_759.as_str()).start_array();
                for item_762 in value_760 {
                    {
                        array_761.value().string(item_762.as_str());
                    }
                }
                array_761.finish();
            }
        }
        object_758.finish();
    }
    if let Some(var_763) = &input.change_request_name {
        object.key("ChangeRequestName").string(var_763.as_str());
    }
    if let Some(var_764) = &input.client_token {
        object.key("ClientToken").string(var_764.as_str());
    }
    if input.auto_approve {
        object.key("AutoApprove").boolean(input.auto_approve);
    }
    if let Some(var_765) = &input.runbooks {
        let mut array_766 = object.key("Runbooks").start_array();
        for item_767 in var_765 {
            {
                #[allow(unused_mut)]
                let mut object_768 = array_766.value().start_object();
                crate::json_ser::serialize_structure_crate_model_runbook(
                    &mut object_768,
                    item_767,
                )?;
                object_768.finish();
            }
        }
        array_766.finish();
    }
    if let Some(var_769) = &input.tags {
        let mut array_770 = object.key("Tags").start_array();
        for item_771 in var_769 {
            {
                #[allow(unused_mut)]
                let mut object_772 = array_770.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_772, item_771)?;
                object_772.finish();
            }
        }
        array_770.finish();
    }
    if let Some(var_773) = &input.scheduled_end_time {
        object
            .key("ScheduledEndTime")
            .date_time(var_773, aws_smithy_types::date_time::Format::EpochSeconds)?;
    }
    if let Some(var_774) = &input.change_details {
        object.key("ChangeDetails").string(var_774.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_start_session_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::StartSessionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_775) = &input.target {
        object.key("Target").string(var_775.as_str());
    }
    if let Some(var_776) = &input.document_name {
        object.key("DocumentName").string(var_776.as_str());
    }
    if let Some(var_777) = &input.reason {
        object.key("Reason").string(var_777.as_str());
    }
    if let Some(var_778) = &input.parameters {
        #[allow(unused_mut)]
        let mut object_779 = object.key("Parameters").start_object();
        for (key_780, value_781) in var_778 {
            {
                let mut array_782 = object_779.key(key_780.as_str()).start_array();
                for item_783 in value_781 {
                    {
                        array_782.value().string(item_783.as_str());
                    }
                }
                array_782.finish();
            }
        }
        object_779.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_stop_automation_execution_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::StopAutomationExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_784) = &input.automation_execution_id {
        object.key("AutomationExecutionId").string(var_784.as_str());
    }
    if let Some(var_785) = &input.r#type {
        object.key("Type").string(var_785.as_str());
    }
    Ok(())
}

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

pub fn serialize_structure_crate_input_unlabel_parameter_version_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UnlabelParameterVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_787) = &input.name {
        object.key("Name").string(var_787.as_str());
    }
    if let Some(var_788) = &input.parameter_version {
        object.key("ParameterVersion").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_788).into()),
        );
    }
    if let Some(var_789) = &input.labels {
        let mut array_790 = object.key("Labels").start_array();
        for item_791 in var_789 {
            {
                array_790.value().string(item_791.as_str());
            }
        }
        array_790.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_association_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateAssociationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_792) = &input.association_id {
        object.key("AssociationId").string(var_792.as_str());
    }
    if let Some(var_793) = &input.parameters {
        #[allow(unused_mut)]
        let mut object_794 = object.key("Parameters").start_object();
        for (key_795, value_796) in var_793 {
            {
                let mut array_797 = object_794.key(key_795.as_str()).start_array();
                for item_798 in value_796 {
                    {
                        array_797.value().string(item_798.as_str());
                    }
                }
                array_797.finish();
            }
        }
        object_794.finish();
    }
    if let Some(var_799) = &input.document_version {
        object.key("DocumentVersion").string(var_799.as_str());
    }
    if let Some(var_800) = &input.schedule_expression {
        object.key("ScheduleExpression").string(var_800.as_str());
    }
    if let Some(var_801) = &input.output_location {
        #[allow(unused_mut)]
        let mut object_802 = object.key("OutputLocation").start_object();
        crate::json_ser::serialize_structure_crate_model_instance_association_output_location(
            &mut object_802,
            var_801,
        )?;
        object_802.finish();
    }
    if let Some(var_803) = &input.name {
        object.key("Name").string(var_803.as_str());
    }
    if let Some(var_804) = &input.targets {
        let mut array_805 = object.key("Targets").start_array();
        for item_806 in var_804 {
            {
                #[allow(unused_mut)]
                let mut object_807 = array_805.value().start_object();
                crate::json_ser::serialize_structure_crate_model_target(&mut object_807, item_806)?;
                object_807.finish();
            }
        }
        array_805.finish();
    }
    if let Some(var_808) = &input.association_name {
        object.key("AssociationName").string(var_808.as_str());
    }
    if let Some(var_809) = &input.association_version {
        object.key("AssociationVersion").string(var_809.as_str());
    }
    if let Some(var_810) = &input.automation_target_parameter_name {
        object
            .key("AutomationTargetParameterName")
            .string(var_810.as_str());
    }
    if let Some(var_811) = &input.max_errors {
        object.key("MaxErrors").string(var_811.as_str());
    }
    if let Some(var_812) = &input.max_concurrency {
        object.key("MaxConcurrency").string(var_812.as_str());
    }
    if let Some(var_813) = &input.compliance_severity {
        object.key("ComplianceSeverity").string(var_813.as_str());
    }
    if let Some(var_814) = &input.sync_compliance {
        object.key("SyncCompliance").string(var_814.as_str());
    }
    if input.apply_only_at_cron_interval {
        object
            .key("ApplyOnlyAtCronInterval")
            .boolean(input.apply_only_at_cron_interval);
    }
    if let Some(var_815) = &input.calendar_names {
        let mut array_816 = object.key("CalendarNames").start_array();
        for item_817 in var_815 {
            {
                array_816.value().string(item_817.as_str());
            }
        }
        array_816.finish();
    }
    if let Some(var_818) = &input.target_locations {
        let mut array_819 = object.key("TargetLocations").start_array();
        for item_820 in var_818 {
            {
                #[allow(unused_mut)]
                let mut object_821 = array_819.value().start_object();
                crate::json_ser::serialize_structure_crate_model_target_location(
                    &mut object_821,
                    item_820,
                )?;
                object_821.finish();
            }
        }
        array_819.finish();
    }
    if let Some(var_822) = &input.schedule_offset {
        object.key("ScheduleOffset").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_822).into()),
        );
    }
    if let Some(var_823) = &input.target_maps {
        let mut array_824 = object.key("TargetMaps").start_array();
        for item_825 in var_823 {
            {
                #[allow(unused_mut)]
                let mut object_826 = array_824.value().start_object();
                for (key_827, value_828) in item_825 {
                    {
                        let mut array_829 = object_826.key(key_827.as_str()).start_array();
                        for item_830 in value_828 {
                            {
                                array_829.value().string(item_830.as_str());
                            }
                        }
                        array_829.finish();
                    }
                }
                object_826.finish();
            }
        }
        array_824.finish();
    }
    if let Some(var_831) = &input.alarm_configuration {
        #[allow(unused_mut)]
        let mut object_832 = object.key("AlarmConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_alarm_configuration(
            &mut object_832,
            var_831,
        )?;
        object_832.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_association_status_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateAssociationStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_833) = &input.name {
        object.key("Name").string(var_833.as_str());
    }
    if let Some(var_834) = &input.instance_id {
        object.key("InstanceId").string(var_834.as_str());
    }
    if let Some(var_835) = &input.association_status {
        #[allow(unused_mut)]
        let mut object_836 = object.key("AssociationStatus").start_object();
        crate::json_ser::serialize_structure_crate_model_association_status(
            &mut object_836,
            var_835,
        )?;
        object_836.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_document_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateDocumentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_837) = &input.content {
        object.key("Content").string(var_837.as_str());
    }
    if let Some(var_838) = &input.attachments {
        let mut array_839 = object.key("Attachments").start_array();
        for item_840 in var_838 {
            {
                #[allow(unused_mut)]
                let mut object_841 = array_839.value().start_object();
                crate::json_ser::serialize_structure_crate_model_attachments_source(
                    &mut object_841,
                    item_840,
                )?;
                object_841.finish();
            }
        }
        array_839.finish();
    }
    if let Some(var_842) = &input.name {
        object.key("Name").string(var_842.as_str());
    }
    if let Some(var_843) = &input.display_name {
        object.key("DisplayName").string(var_843.as_str());
    }
    if let Some(var_844) = &input.version_name {
        object.key("VersionName").string(var_844.as_str());
    }
    if let Some(var_845) = &input.document_version {
        object.key("DocumentVersion").string(var_845.as_str());
    }
    if let Some(var_846) = &input.document_format {
        object.key("DocumentFormat").string(var_846.as_str());
    }
    if let Some(var_847) = &input.target_type {
        object.key("TargetType").string(var_847.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 DocumentFormat

fn as_ref(&self) -> &str

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

impl Clone for DocumentFormat

fn clone(&self) -> DocumentFormat

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DocumentFormat

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

Formats the value using the given formatter.

impl From<&str> for DocumentFormat

fn from(s: &str) -> Self

Converts to this type from the input type.

impl FromStr for DocumentFormat

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 DocumentFormat

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 DocumentFormat

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

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

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

impl StructuralEq for DocumentFormat

impl StructuralPartialEq for DocumentFormat