json_ser.rs

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
pub fn serialize_structure_crate_input_batch_check_layer_availability_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::BatchCheckLayerAvailabilityInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_1) = &input.registry_id {
        object.key("registryId").string(var_1.as_str());
    }
    if let Some(var_2) = &input.repository_name {
        object.key("repositoryName").string(var_2.as_str());
    }
    if let Some(var_3) = &input.layer_digests {
        let mut array_4 = object.key("layerDigests").start_array();
        for item_5 in var_3 {
            {
                array_4.value().string(item_5.as_str());
            }
        }
        array_4.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_batch_delete_image_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::BatchDeleteImageInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_6) = &input.registry_id {
        object.key("registryId").string(var_6.as_str());
    }
    if let Some(var_7) = &input.repository_name {
        object.key("repositoryName").string(var_7.as_str());
    }
    if let Some(var_8) = &input.image_ids {
        let mut array_9 = object.key("imageIds").start_array();
        for item_10 in var_8 {
            {
                let mut object_11 = array_9.value().start_object();
                crate::json_ser::serialize_structure_crate_model_image_identifier(
                    &mut object_11,
                    item_10,
                )?;
                object_11.finish();
            }
        }
        array_9.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_batch_get_image_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::BatchGetImageInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_12) = &input.registry_id {
        object.key("registryId").string(var_12.as_str());
    }
    if let Some(var_13) = &input.repository_name {
        object.key("repositoryName").string(var_13.as_str());
    }
    if let Some(var_14) = &input.image_ids {
        let mut array_15 = object.key("imageIds").start_array();
        for item_16 in var_14 {
            {
                let mut object_17 = array_15.value().start_object();
                crate::json_ser::serialize_structure_crate_model_image_identifier(
                    &mut object_17,
                    item_16,
                )?;
                object_17.finish();
            }
        }
        array_15.finish();
    }
    if let Some(var_18) = &input.accepted_media_types {
        let mut array_19 = object.key("acceptedMediaTypes").start_array();
        for item_20 in var_18 {
            {
                array_19.value().string(item_20.as_str());
            }
        }
        array_19.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_batch_get_repository_scanning_configuration_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::BatchGetRepositoryScanningConfigurationInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_21) = &input.repository_names {
        let mut array_22 = object.key("repositoryNames").start_array();
        for item_23 in var_21 {
            {
                array_22.value().string(item_23.as_str());
            }
        }
        array_22.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_complete_layer_upload_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CompleteLayerUploadInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_24) = &input.registry_id {
        object.key("registryId").string(var_24.as_str());
    }
    if let Some(var_25) = &input.repository_name {
        object.key("repositoryName").string(var_25.as_str());
    }
    if let Some(var_26) = &input.upload_id {
        object.key("uploadId").string(var_26.as_str());
    }
    if let Some(var_27) = &input.layer_digests {
        let mut array_28 = object.key("layerDigests").start_array();
        for item_29 in var_27 {
            {
                array_28.value().string(item_29.as_str());
            }
        }
        array_28.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_pull_through_cache_rule_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreatePullThroughCacheRuleInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_30) = &input.ecr_repository_prefix {
        object.key("ecrRepositoryPrefix").string(var_30.as_str());
    }
    if let Some(var_31) = &input.upstream_registry_url {
        object.key("upstreamRegistryUrl").string(var_31.as_str());
    }
    if let Some(var_32) = &input.registry_id {
        object.key("registryId").string(var_32.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_repository_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateRepositoryInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_33) = &input.registry_id {
        object.key("registryId").string(var_33.as_str());
    }
    if let Some(var_34) = &input.repository_name {
        object.key("repositoryName").string(var_34.as_str());
    }
    if let Some(var_35) = &input.tags {
        let mut array_36 = object.key("tags").start_array();
        for item_37 in var_35 {
            {
                let mut object_38 = array_36.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_38, item_37)?;
                object_38.finish();
            }
        }
        array_36.finish();
    }
    if let Some(var_39) = &input.image_tag_mutability {
        object.key("imageTagMutability").string(var_39.as_str());
    }
    if let Some(var_40) = &input.image_scanning_configuration {
        let mut object_41 = object.key("imageScanningConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_image_scanning_configuration(
            &mut object_41,
            var_40,
        )?;
        object_41.finish();
    }
    if let Some(var_42) = &input.encryption_configuration {
        let mut object_43 = object.key("encryptionConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_encryption_configuration(
            &mut object_43,
            var_42,
        )?;
        object_43.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_lifecycle_policy_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteLifecyclePolicyInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_44) = &input.registry_id {
        object.key("registryId").string(var_44.as_str());
    }
    if let Some(var_45) = &input.repository_name {
        object.key("repositoryName").string(var_45.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_pull_through_cache_rule_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeletePullThroughCacheRuleInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_46) = &input.ecr_repository_prefix {
        object.key("ecrRepositoryPrefix").string(var_46.as_str());
    }
    if let Some(var_47) = &input.registry_id {
        object.key("registryId").string(var_47.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_repository_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteRepositoryInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_48) = &input.registry_id {
        object.key("registryId").string(var_48.as_str());
    }
    if let Some(var_49) = &input.repository_name {
        object.key("repositoryName").string(var_49.as_str());
    }
    if input.force {
        object.key("force").boolean(input.force);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_repository_policy_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteRepositoryPolicyInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_50) = &input.registry_id {
        object.key("registryId").string(var_50.as_str());
    }
    if let Some(var_51) = &input.repository_name {
        object.key("repositoryName").string(var_51.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_image_replication_status_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeImageReplicationStatusInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_52) = &input.repository_name {
        object.key("repositoryName").string(var_52.as_str());
    }
    if let Some(var_53) = &input.image_id {
        let mut object_54 = object.key("imageId").start_object();
        crate::json_ser::serialize_structure_crate_model_image_identifier(&mut object_54, var_53)?;
        object_54.finish();
    }
    if let Some(var_55) = &input.registry_id {
        object.key("registryId").string(var_55.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_images_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeImagesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_56) = &input.registry_id {
        object.key("registryId").string(var_56.as_str());
    }
    if let Some(var_57) = &input.repository_name {
        object.key("repositoryName").string(var_57.as_str());
    }
    if let Some(var_58) = &input.image_ids {
        let mut array_59 = object.key("imageIds").start_array();
        for item_60 in var_58 {
            {
                let mut object_61 = array_59.value().start_object();
                crate::json_ser::serialize_structure_crate_model_image_identifier(
                    &mut object_61,
                    item_60,
                )?;
                object_61.finish();
            }
        }
        array_59.finish();
    }
    if let Some(var_62) = &input.next_token {
        object.key("nextToken").string(var_62.as_str());
    }
    if let Some(var_63) = &input.max_results {
        object.key("maxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_63).into()),
        );
    }
    if let Some(var_64) = &input.filter {
        let mut object_65 = object.key("filter").start_object();
        crate::json_ser::serialize_structure_crate_model_describe_images_filter(
            &mut object_65,
            var_64,
        )?;
        object_65.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_image_scan_findings_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeImageScanFindingsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_66) = &input.registry_id {
        object.key("registryId").string(var_66.as_str());
    }
    if let Some(var_67) = &input.repository_name {
        object.key("repositoryName").string(var_67.as_str());
    }
    if let Some(var_68) = &input.image_id {
        let mut object_69 = object.key("imageId").start_object();
        crate::json_ser::serialize_structure_crate_model_image_identifier(&mut object_69, var_68)?;
        object_69.finish();
    }
    if let Some(var_70) = &input.next_token {
        object.key("nextToken").string(var_70.as_str());
    }
    if let Some(var_71) = &input.max_results {
        object.key("maxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_71).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_pull_through_cache_rules_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribePullThroughCacheRulesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_72) = &input.registry_id {
        object.key("registryId").string(var_72.as_str());
    }
    if let Some(var_73) = &input.ecr_repository_prefixes {
        let mut array_74 = object.key("ecrRepositoryPrefixes").start_array();
        for item_75 in var_73 {
            {
                array_74.value().string(item_75.as_str());
            }
        }
        array_74.finish();
    }
    if let Some(var_76) = &input.next_token {
        object.key("nextToken").string(var_76.as_str());
    }
    if let Some(var_77) = &input.max_results {
        object.key("maxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_77).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_repositories_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeRepositoriesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_78) = &input.registry_id {
        object.key("registryId").string(var_78.as_str());
    }
    if let Some(var_79) = &input.repository_names {
        let mut array_80 = object.key("repositoryNames").start_array();
        for item_81 in var_79 {
            {
                array_80.value().string(item_81.as_str());
            }
        }
        array_80.finish();
    }
    if let Some(var_82) = &input.next_token {
        object.key("nextToken").string(var_82.as_str());
    }
    if let Some(var_83) = &input.max_results {
        object.key("maxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_83).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_authorization_token_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetAuthorizationTokenInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_84) = &input.registry_ids {
        let mut array_85 = object.key("registryIds").start_array();
        for item_86 in var_84 {
            {
                array_85.value().string(item_86.as_str());
            }
        }
        array_85.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_download_url_for_layer_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetDownloadUrlForLayerInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_87) = &input.registry_id {
        object.key("registryId").string(var_87.as_str());
    }
    if let Some(var_88) = &input.repository_name {
        object.key("repositoryName").string(var_88.as_str());
    }
    if let Some(var_89) = &input.layer_digest {
        object.key("layerDigest").string(var_89.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_lifecycle_policy_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetLifecyclePolicyInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_90) = &input.registry_id {
        object.key("registryId").string(var_90.as_str());
    }
    if let Some(var_91) = &input.repository_name {
        object.key("repositoryName").string(var_91.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_lifecycle_policy_preview_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetLifecyclePolicyPreviewInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_92) = &input.registry_id {
        object.key("registryId").string(var_92.as_str());
    }
    if let Some(var_93) = &input.repository_name {
        object.key("repositoryName").string(var_93.as_str());
    }
    if let Some(var_94) = &input.image_ids {
        let mut array_95 = object.key("imageIds").start_array();
        for item_96 in var_94 {
            {
                let mut object_97 = array_95.value().start_object();
                crate::json_ser::serialize_structure_crate_model_image_identifier(
                    &mut object_97,
                    item_96,
                )?;
                object_97.finish();
            }
        }
        array_95.finish();
    }
    if let Some(var_98) = &input.next_token {
        object.key("nextToken").string(var_98.as_str());
    }
    if let Some(var_99) = &input.max_results {
        object.key("maxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_99).into()),
        );
    }
    if let Some(var_100) = &input.filter {
        let mut object_101 = object.key("filter").start_object();
        crate::json_ser::serialize_structure_crate_model_lifecycle_policy_preview_filter(
            &mut object_101,
            var_100,
        )?;
        object_101.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_repository_policy_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetRepositoryPolicyInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_102) = &input.registry_id {
        object.key("registryId").string(var_102.as_str());
    }
    if let Some(var_103) = &input.repository_name {
        object.key("repositoryName").string(var_103.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_initiate_layer_upload_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::InitiateLayerUploadInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_104) = &input.registry_id {
        object.key("registryId").string(var_104.as_str());
    }
    if let Some(var_105) = &input.repository_name {
        object.key("repositoryName").string(var_105.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_images_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListImagesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_106) = &input.registry_id {
        object.key("registryId").string(var_106.as_str());
    }
    if let Some(var_107) = &input.repository_name {
        object.key("repositoryName").string(var_107.as_str());
    }
    if let Some(var_108) = &input.next_token {
        object.key("nextToken").string(var_108.as_str());
    }
    if let Some(var_109) = &input.max_results {
        object.key("maxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_109).into()),
        );
    }
    if let Some(var_110) = &input.filter {
        let mut object_111 = object.key("filter").start_object();
        crate::json_ser::serialize_structure_crate_model_list_images_filter(
            &mut object_111,
            var_110,
        )?;
        object_111.finish();
    }
    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::SerializationError> {
    if let Some(var_112) = &input.resource_arn {
        object.key("resourceArn").string(var_112.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_image_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutImageInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_113) = &input.registry_id {
        object.key("registryId").string(var_113.as_str());
    }
    if let Some(var_114) = &input.repository_name {
        object.key("repositoryName").string(var_114.as_str());
    }
    if let Some(var_115) = &input.image_manifest {
        object.key("imageManifest").string(var_115.as_str());
    }
    if let Some(var_116) = &input.image_manifest_media_type {
        object
            .key("imageManifestMediaType")
            .string(var_116.as_str());
    }
    if let Some(var_117) = &input.image_tag {
        object.key("imageTag").string(var_117.as_str());
    }
    if let Some(var_118) = &input.image_digest {
        object.key("imageDigest").string(var_118.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_image_scanning_configuration_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutImageScanningConfigurationInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_119) = &input.registry_id {
        object.key("registryId").string(var_119.as_str());
    }
    if let Some(var_120) = &input.repository_name {
        object.key("repositoryName").string(var_120.as_str());
    }
    if let Some(var_121) = &input.image_scanning_configuration {
        let mut object_122 = object.key("imageScanningConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_image_scanning_configuration(
            &mut object_122,
            var_121,
        )?;
        object_122.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_image_tag_mutability_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutImageTagMutabilityInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_123) = &input.registry_id {
        object.key("registryId").string(var_123.as_str());
    }
    if let Some(var_124) = &input.repository_name {
        object.key("repositoryName").string(var_124.as_str());
    }
    if let Some(var_125) = &input.image_tag_mutability {
        object.key("imageTagMutability").string(var_125.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_lifecycle_policy_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutLifecyclePolicyInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_126) = &input.registry_id {
        object.key("registryId").string(var_126.as_str());
    }
    if let Some(var_127) = &input.repository_name {
        object.key("repositoryName").string(var_127.as_str());
    }
    if let Some(var_128) = &input.lifecycle_policy_text {
        object.key("lifecyclePolicyText").string(var_128.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_registry_policy_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutRegistryPolicyInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_129) = &input.policy_text {
        object.key("policyText").string(var_129.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_registry_scanning_configuration_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutRegistryScanningConfigurationInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_130) = &input.scan_type {
        object.key("scanType").string(var_130.as_str());
    }
    if let Some(var_131) = &input.rules {
        let mut array_132 = object.key("rules").start_array();
        for item_133 in var_131 {
            {
                let mut object_134 = array_132.value().start_object();
                crate::json_ser::serialize_structure_crate_model_registry_scanning_rule(
                    &mut object_134,
                    item_133,
                )?;
                object_134.finish();
            }
        }
        array_132.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_replication_configuration_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutReplicationConfigurationInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_135) = &input.replication_configuration {
        let mut object_136 = object.key("replicationConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_replication_configuration(
            &mut object_136,
            var_135,
        )?;
        object_136.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_set_repository_policy_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::SetRepositoryPolicyInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_137) = &input.registry_id {
        object.key("registryId").string(var_137.as_str());
    }
    if let Some(var_138) = &input.repository_name {
        object.key("repositoryName").string(var_138.as_str());
    }
    if let Some(var_139) = &input.policy_text {
        object.key("policyText").string(var_139.as_str());
    }
    if input.force {
        object.key("force").boolean(input.force);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_start_image_scan_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::StartImageScanInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_140) = &input.registry_id {
        object.key("registryId").string(var_140.as_str());
    }
    if let Some(var_141) = &input.repository_name {
        object.key("repositoryName").string(var_141.as_str());
    }
    if let Some(var_142) = &input.image_id {
        let mut object_143 = object.key("imageId").start_object();
        crate::json_ser::serialize_structure_crate_model_image_identifier(
            &mut object_143,
            var_142,
        )?;
        object_143.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_start_lifecycle_policy_preview_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::StartLifecyclePolicyPreviewInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_144) = &input.registry_id {
        object.key("registryId").string(var_144.as_str());
    }
    if let Some(var_145) = &input.repository_name {
        object.key("repositoryName").string(var_145.as_str());
    }
    if let Some(var_146) = &input.lifecycle_policy_text {
        object.key("lifecyclePolicyText").string(var_146.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_tag_resource_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_147) = &input.resource_arn {
        object.key("resourceArn").string(var_147.as_str());
    }
    if let Some(var_148) = &input.tags {
        let mut array_149 = object.key("tags").start_array();
        for item_150 in var_148 {
            {
                let mut object_151 = array_149.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_151, item_150)?;
                object_151.finish();
            }
        }
        array_149.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_untag_resource_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UntagResourceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_152) = &input.resource_arn {
        object.key("resourceArn").string(var_152.as_str());
    }
    if let Some(var_153) = &input.tag_keys {
        let mut array_154 = object.key("tagKeys").start_array();
        for item_155 in var_153 {
            {
                array_154.value().string(item_155.as_str());
            }
        }
        array_154.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_upload_layer_part_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UploadLayerPartInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_156) = &input.registry_id {
        object.key("registryId").string(var_156.as_str());
    }
    if let Some(var_157) = &input.repository_name {
        object.key("repositoryName").string(var_157.as_str());
    }
    if let Some(var_158) = &input.upload_id {
        object.key("uploadId").string(var_158.as_str());
    }
    if let Some(var_159) = &input.part_first_byte {
        object.key("partFirstByte").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_159).into()),
        );
    }
    if let Some(var_160) = &input.part_last_byte {
        object.key("partLastByte").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_160).into()),
        );
    }
    if let Some(var_161) = &input.layer_part_blob {
        object
            .key("layerPartBlob")
            .string_unchecked(&aws_smithy_types::base64::encode(var_161));
    }
    Ok(())
}

pub fn serialize_structure_crate_model_image_identifier(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ImageIdentifier,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_162) = &input.image_digest {
        object.key("imageDigest").string(var_162.as_str());
    }
    if let Some(var_163) = &input.image_tag {
        object.key("imageTag").string(var_163.as_str());
    }
    Ok(())
}

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

pub fn serialize_structure_crate_model_image_scanning_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ImageScanningConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.scan_on_push {
        object.key("scanOnPush").boolean(input.scan_on_push);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_encryption_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::EncryptionConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_166) = &input.encryption_type {
        object.key("encryptionType").string(var_166.as_str());
    }
    if let Some(var_167) = &input.kms_key {
        object.key("kmsKey").string(var_167.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_describe_images_filter(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DescribeImagesFilter,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_168) = &input.tag_status {
        object.key("tagStatus").string(var_168.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_lifecycle_policy_preview_filter(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::LifecyclePolicyPreviewFilter,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_169) = &input.tag_status {
        object.key("tagStatus").string(var_169.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_list_images_filter(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ListImagesFilter,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_170) = &input.tag_status {
        object.key("tagStatus").string(var_170.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_registry_scanning_rule(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::RegistryScanningRule,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_171) = &input.scan_frequency {
        object.key("scanFrequency").string(var_171.as_str());
    }
    if let Some(var_172) = &input.repository_filters {
        let mut array_173 = object.key("repositoryFilters").start_array();
        for item_174 in var_172 {
            {
                let mut object_175 = array_173.value().start_object();
                crate::json_ser::serialize_structure_crate_model_scanning_repository_filter(
                    &mut object_175,
                    item_174,
                )?;
                object_175.finish();
            }
        }
        array_173.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_replication_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ReplicationConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_176) = &input.rules {
        let mut array_177 = object.key("rules").start_array();
        for item_178 in var_176 {
            {
                let mut object_179 = array_177.value().start_object();
                crate::json_ser::serialize_structure_crate_model_replication_rule(
                    &mut object_179,
                    item_178,
                )?;
                object_179.finish();
            }
        }
        array_177.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_scanning_repository_filter(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ScanningRepositoryFilter,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_180) = &input.filter {
        object.key("filter").string(var_180.as_str());
    }
    if let Some(var_181) = &input.filter_type {
        object.key("filterType").string(var_181.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_replication_rule(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ReplicationRule,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_182) = &input.destinations {
        let mut array_183 = object.key("destinations").start_array();
        for item_184 in var_182 {
            {
                let mut object_185 = array_183.value().start_object();
                crate::json_ser::serialize_structure_crate_model_replication_destination(
                    &mut object_185,
                    item_184,
                )?;
                object_185.finish();
            }
        }
        array_183.finish();
    }
    if let Some(var_186) = &input.repository_filters {
        let mut array_187 = object.key("repositoryFilters").start_array();
        for item_188 in var_186 {
            {
                let mut object_189 = array_187.value().start_object();
                crate::json_ser::serialize_structure_crate_model_repository_filter(
                    &mut object_189,
                    item_188,
                )?;
                object_189.finish();
            }
        }
        array_187.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_replication_destination(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ReplicationDestination,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_190) = &input.region {
        object.key("region").string(var_190.as_str());
    }
    if let Some(var_191) = &input.registry_id {
        object.key("registryId").string(var_191.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_repository_filter(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::RepositoryFilter,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_192) = &input.filter {
        object.key("filter").string(var_192.as_str());
    }
    if let Some(var_193) = &input.filter_type {
        object.key("filterType").string(var_193.as_str());
    }
    Ok(())
}