pub fn serialize_structure_crate_input_cancel_image_creation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CancelImageCreationInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_1) = &input.client_token {
object.key("clientToken").string(var_1);
}
if let Some(var_2) = &input.image_build_version_arn {
object.key("imageBuildVersionArn").string(var_2);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_component_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateComponentInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_3) = &input.change_description {
object.key("changeDescription").string(var_3);
}
if let Some(var_4) = &input.client_token {
object.key("clientToken").string(var_4);
}
if let Some(var_5) = &input.data {
object.key("data").string(var_5);
}
if let Some(var_6) = &input.description {
object.key("description").string(var_6);
}
if let Some(var_7) = &input.kms_key_id {
object.key("kmsKeyId").string(var_7);
}
if let Some(var_8) = &input.name {
object.key("name").string(var_8);
}
if let Some(var_9) = &input.platform {
object.key("platform").string(var_9.as_str());
}
if let Some(var_10) = &input.semantic_version {
object.key("semanticVersion").string(var_10);
}
if let Some(var_11) = &input.supported_os_versions {
let mut array_12 = object.key("supportedOsVersions").start_array();
for item_13 in var_11 {
{
array_12.value().string(item_13);
}
}
array_12.finish();
}
if let Some(var_14) = &input.tags {
let mut object_15 = object.key("tags").start_object();
for (key_16, value_17) in var_14 {
{
object_15.key(key_16).string(value_17);
}
}
object_15.finish();
}
if let Some(var_18) = &input.uri {
object.key("uri").string(var_18);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_container_recipe_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateContainerRecipeInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_19) = &input.client_token {
object.key("clientToken").string(var_19);
}
if let Some(var_20) = &input.components {
let mut array_21 = object.key("components").start_array();
for item_22 in var_20 {
{
let mut object_23 = array_21.value().start_object();
crate::json_ser::serialize_structure_crate_model_component_configuration(
&mut object_23,
item_22,
)?;
object_23.finish();
}
}
array_21.finish();
}
if let Some(var_24) = &input.container_type {
object.key("containerType").string(var_24.as_str());
}
if let Some(var_25) = &input.description {
object.key("description").string(var_25);
}
if let Some(var_26) = &input.dockerfile_template_data {
object.key("dockerfileTemplateData").string(var_26);
}
if let Some(var_27) = &input.dockerfile_template_uri {
object.key("dockerfileTemplateUri").string(var_27);
}
if let Some(var_28) = &input.image_os_version_override {
object.key("imageOsVersionOverride").string(var_28);
}
if let Some(var_29) = &input.instance_configuration {
let mut object_30 = object.key("instanceConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_instance_configuration(
&mut object_30,
var_29,
)?;
object_30.finish();
}
if let Some(var_31) = &input.kms_key_id {
object.key("kmsKeyId").string(var_31);
}
if let Some(var_32) = &input.name {
object.key("name").string(var_32);
}
if let Some(var_33) = &input.parent_image {
object.key("parentImage").string(var_33);
}
if let Some(var_34) = &input.platform_override {
object.key("platformOverride").string(var_34.as_str());
}
if let Some(var_35) = &input.semantic_version {
object.key("semanticVersion").string(var_35);
}
if let Some(var_36) = &input.tags {
let mut object_37 = object.key("tags").start_object();
for (key_38, value_39) in var_36 {
{
object_37.key(key_38).string(value_39);
}
}
object_37.finish();
}
if let Some(var_40) = &input.target_repository {
let mut object_41 = object.key("targetRepository").start_object();
crate::json_ser::serialize_structure_crate_model_target_container_repository(
&mut object_41,
var_40,
)?;
object_41.finish();
}
if let Some(var_42) = &input.working_directory {
object.key("workingDirectory").string(var_42);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_distribution_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDistributionConfigurationInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_43) = &input.client_token {
object.key("clientToken").string(var_43);
}
if let Some(var_44) = &input.description {
object.key("description").string(var_44);
}
if let Some(var_45) = &input.distributions {
let mut array_46 = object.key("distributions").start_array();
for item_47 in var_45 {
{
let mut object_48 = array_46.value().start_object();
crate::json_ser::serialize_structure_crate_model_distribution(
&mut object_48,
item_47,
)?;
object_48.finish();
}
}
array_46.finish();
}
if let Some(var_49) = &input.name {
object.key("name").string(var_49);
}
if let Some(var_50) = &input.tags {
let mut object_51 = object.key("tags").start_object();
for (key_52, value_53) in var_50 {
{
object_51.key(key_52).string(value_53);
}
}
object_51.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_image_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateImageInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_54) = &input.client_token {
object.key("clientToken").string(var_54);
}
if let Some(var_55) = &input.container_recipe_arn {
object.key("containerRecipeArn").string(var_55);
}
if let Some(var_56) = &input.distribution_configuration_arn {
object.key("distributionConfigurationArn").string(var_56);
}
if let Some(var_57) = &input.enhanced_image_metadata_enabled {
object.key("enhancedImageMetadataEnabled").boolean(*var_57);
}
if let Some(var_58) = &input.image_recipe_arn {
object.key("imageRecipeArn").string(var_58);
}
if let Some(var_59) = &input.image_tests_configuration {
let mut object_60 = object.key("imageTestsConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_image_tests_configuration(
&mut object_60,
var_59,
)?;
object_60.finish();
}
if let Some(var_61) = &input.infrastructure_configuration_arn {
object.key("infrastructureConfigurationArn").string(var_61);
}
if let Some(var_62) = &input.tags {
let mut object_63 = object.key("tags").start_object();
for (key_64, value_65) in var_62 {
{
object_63.key(key_64).string(value_65);
}
}
object_63.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_image_pipeline_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateImagePipelineInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_66) = &input.client_token {
object.key("clientToken").string(var_66);
}
if let Some(var_67) = &input.container_recipe_arn {
object.key("containerRecipeArn").string(var_67);
}
if let Some(var_68) = &input.description {
object.key("description").string(var_68);
}
if let Some(var_69) = &input.distribution_configuration_arn {
object.key("distributionConfigurationArn").string(var_69);
}
if let Some(var_70) = &input.enhanced_image_metadata_enabled {
object.key("enhancedImageMetadataEnabled").boolean(*var_70);
}
if let Some(var_71) = &input.image_recipe_arn {
object.key("imageRecipeArn").string(var_71);
}
if let Some(var_72) = &input.image_tests_configuration {
let mut object_73 = object.key("imageTestsConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_image_tests_configuration(
&mut object_73,
var_72,
)?;
object_73.finish();
}
if let Some(var_74) = &input.infrastructure_configuration_arn {
object.key("infrastructureConfigurationArn").string(var_74);
}
if let Some(var_75) = &input.name {
object.key("name").string(var_75);
}
if let Some(var_76) = &input.schedule {
let mut object_77 = object.key("schedule").start_object();
crate::json_ser::serialize_structure_crate_model_schedule(&mut object_77, var_76)?;
object_77.finish();
}
if let Some(var_78) = &input.status {
object.key("status").string(var_78.as_str());
}
if let Some(var_79) = &input.tags {
let mut object_80 = object.key("tags").start_object();
for (key_81, value_82) in var_79 {
{
object_80.key(key_81).string(value_82);
}
}
object_80.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_image_recipe_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateImageRecipeInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_83) = &input.additional_instance_configuration {
let mut object_84 = object.key("additionalInstanceConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_additional_instance_configuration(
&mut object_84,
var_83,
)?;
object_84.finish();
}
if let Some(var_85) = &input.block_device_mappings {
let mut array_86 = object.key("blockDeviceMappings").start_array();
for item_87 in var_85 {
{
let mut object_88 = array_86.value().start_object();
crate::json_ser::serialize_structure_crate_model_instance_block_device_mapping(
&mut object_88,
item_87,
)?;
object_88.finish();
}
}
array_86.finish();
}
if let Some(var_89) = &input.client_token {
object.key("clientToken").string(var_89);
}
if let Some(var_90) = &input.components {
let mut array_91 = object.key("components").start_array();
for item_92 in var_90 {
{
let mut object_93 = array_91.value().start_object();
crate::json_ser::serialize_structure_crate_model_component_configuration(
&mut object_93,
item_92,
)?;
object_93.finish();
}
}
array_91.finish();
}
if let Some(var_94) = &input.description {
object.key("description").string(var_94);
}
if let Some(var_95) = &input.name {
object.key("name").string(var_95);
}
if let Some(var_96) = &input.parent_image {
object.key("parentImage").string(var_96);
}
if let Some(var_97) = &input.semantic_version {
object.key("semanticVersion").string(var_97);
}
if let Some(var_98) = &input.tags {
let mut object_99 = object.key("tags").start_object();
for (key_100, value_101) in var_98 {
{
object_99.key(key_100).string(value_101);
}
}
object_99.finish();
}
if let Some(var_102) = &input.working_directory {
object.key("workingDirectory").string(var_102);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_infrastructure_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateInfrastructureConfigurationInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_103) = &input.client_token {
object.key("clientToken").string(var_103);
}
if let Some(var_104) = &input.description {
object.key("description").string(var_104);
}
if let Some(var_105) = &input.instance_metadata_options {
let mut object_106 = object.key("instanceMetadataOptions").start_object();
crate::json_ser::serialize_structure_crate_model_instance_metadata_options(
&mut object_106,
var_105,
)?;
object_106.finish();
}
if let Some(var_107) = &input.instance_profile_name {
object.key("instanceProfileName").string(var_107);
}
if let Some(var_108) = &input.instance_types {
let mut array_109 = object.key("instanceTypes").start_array();
for item_110 in var_108 {
{
array_109.value().string(item_110);
}
}
array_109.finish();
}
if let Some(var_111) = &input.key_pair {
object.key("keyPair").string(var_111);
}
if let Some(var_112) = &input.logging {
let mut object_113 = object.key("logging").start_object();
crate::json_ser::serialize_structure_crate_model_logging(&mut object_113, var_112)?;
object_113.finish();
}
if let Some(var_114) = &input.name {
object.key("name").string(var_114);
}
if let Some(var_115) = &input.resource_tags {
let mut object_116 = object.key("resourceTags").start_object();
for (key_117, value_118) in var_115 {
{
object_116.key(key_117).string(value_118);
}
}
object_116.finish();
}
if let Some(var_119) = &input.security_group_ids {
let mut array_120 = object.key("securityGroupIds").start_array();
for item_121 in var_119 {
{
array_120.value().string(item_121);
}
}
array_120.finish();
}
if let Some(var_122) = &input.sns_topic_arn {
object.key("snsTopicArn").string(var_122);
}
if let Some(var_123) = &input.subnet_id {
object.key("subnetId").string(var_123);
}
if let Some(var_124) = &input.tags {
let mut object_125 = object.key("tags").start_object();
for (key_126, value_127) in var_124 {
{
object_125.key(key_126).string(value_127);
}
}
object_125.finish();
}
if let Some(var_128) = &input.terminate_instance_on_failure {
object.key("terminateInstanceOnFailure").boolean(*var_128);
}
Ok(())
}
pub fn serialize_structure_crate_input_import_component_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ImportComponentInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_129) = &input.change_description {
object.key("changeDescription").string(var_129);
}
if let Some(var_130) = &input.client_token {
object.key("clientToken").string(var_130);
}
if let Some(var_131) = &input.data {
object.key("data").string(var_131);
}
if let Some(var_132) = &input.description {
object.key("description").string(var_132);
}
if let Some(var_133) = &input.format {
object.key("format").string(var_133.as_str());
}
if let Some(var_134) = &input.kms_key_id {
object.key("kmsKeyId").string(var_134);
}
if let Some(var_135) = &input.name {
object.key("name").string(var_135);
}
if let Some(var_136) = &input.platform {
object.key("platform").string(var_136.as_str());
}
if let Some(var_137) = &input.semantic_version {
object.key("semanticVersion").string(var_137);
}
if let Some(var_138) = &input.tags {
let mut object_139 = object.key("tags").start_object();
for (key_140, value_141) in var_138 {
{
object_139.key(key_140).string(value_141);
}
}
object_139.finish();
}
if let Some(var_142) = &input.r#type {
object.key("type").string(var_142.as_str());
}
if let Some(var_143) = &input.uri {
object.key("uri").string(var_143);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_component_build_versions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListComponentBuildVersionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_144) = &input.component_version_arn {
object.key("componentVersionArn").string(var_144);
}
if let Some(var_145) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_145).into()),
);
}
if let Some(var_146) = &input.next_token {
object.key("nextToken").string(var_146);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_components_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListComponentsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if input.by_name {
object.key("byName").boolean(input.by_name);
}
if let Some(var_147) = &input.filters {
let mut array_148 = object.key("filters").start_array();
for item_149 in var_147 {
{
let mut object_150 = array_148.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_150, item_149)?;
object_150.finish();
}
}
array_148.finish();
}
if let Some(var_151) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_151).into()),
);
}
if let Some(var_152) = &input.next_token {
object.key("nextToken").string(var_152);
}
if let Some(var_153) = &input.owner {
object.key("owner").string(var_153.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_container_recipes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListContainerRecipesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_154) = &input.filters {
let mut array_155 = object.key("filters").start_array();
for item_156 in var_154 {
{
let mut object_157 = array_155.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_157, item_156)?;
object_157.finish();
}
}
array_155.finish();
}
if let Some(var_158) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_158).into()),
);
}
if let Some(var_159) = &input.next_token {
object.key("nextToken").string(var_159);
}
if let Some(var_160) = &input.owner {
object.key("owner").string(var_160.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_distribution_configurations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDistributionConfigurationsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_161) = &input.filters {
let mut array_162 = object.key("filters").start_array();
for item_163 in var_161 {
{
let mut object_164 = array_162.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_164, item_163)?;
object_164.finish();
}
}
array_162.finish();
}
if let Some(var_165) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_165).into()),
);
}
if let Some(var_166) = &input.next_token {
object.key("nextToken").string(var_166);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_image_build_versions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListImageBuildVersionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_167) = &input.filters {
let mut array_168 = object.key("filters").start_array();
for item_169 in var_167 {
{
let mut object_170 = array_168.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_170, item_169)?;
object_170.finish();
}
}
array_168.finish();
}
if let Some(var_171) = &input.image_version_arn {
object.key("imageVersionArn").string(var_171);
}
if let Some(var_172) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_172).into()),
);
}
if let Some(var_173) = &input.next_token {
object.key("nextToken").string(var_173);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_image_packages_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListImagePackagesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_174) = &input.image_build_version_arn {
object.key("imageBuildVersionArn").string(var_174);
}
if let Some(var_175) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_175).into()),
);
}
if let Some(var_176) = &input.next_token {
object.key("nextToken").string(var_176);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_image_pipeline_images_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListImagePipelineImagesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_177) = &input.filters {
let mut array_178 = object.key("filters").start_array();
for item_179 in var_177 {
{
let mut object_180 = array_178.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_180, item_179)?;
object_180.finish();
}
}
array_178.finish();
}
if let Some(var_181) = &input.image_pipeline_arn {
object.key("imagePipelineArn").string(var_181);
}
if let Some(var_182) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_182).into()),
);
}
if let Some(var_183) = &input.next_token {
object.key("nextToken").string(var_183);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_image_pipelines_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListImagePipelinesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_184) = &input.filters {
let mut array_185 = object.key("filters").start_array();
for item_186 in var_184 {
{
let mut object_187 = array_185.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_187, item_186)?;
object_187.finish();
}
}
array_185.finish();
}
if let Some(var_188) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_188).into()),
);
}
if let Some(var_189) = &input.next_token {
object.key("nextToken").string(var_189);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_image_recipes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListImageRecipesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_190) = &input.filters {
let mut array_191 = object.key("filters").start_array();
for item_192 in var_190 {
{
let mut object_193 = array_191.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_193, item_192)?;
object_193.finish();
}
}
array_191.finish();
}
if let Some(var_194) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_194).into()),
);
}
if let Some(var_195) = &input.next_token {
object.key("nextToken").string(var_195);
}
if let Some(var_196) = &input.owner {
object.key("owner").string(var_196.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 input.by_name {
object.key("byName").boolean(input.by_name);
}
if let Some(var_197) = &input.filters {
let mut array_198 = object.key("filters").start_array();
for item_199 in var_197 {
{
let mut object_200 = array_198.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_200, item_199)?;
object_200.finish();
}
}
array_198.finish();
}
if let Some(var_201) = &input.include_deprecated {
object.key("includeDeprecated").boolean(*var_201);
}
if let Some(var_202) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_202).into()),
);
}
if let Some(var_203) = &input.next_token {
object.key("nextToken").string(var_203);
}
if let Some(var_204) = &input.owner {
object.key("owner").string(var_204.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_infrastructure_configurations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListInfrastructureConfigurationsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_205) = &input.filters {
let mut array_206 = object.key("filters").start_array();
for item_207 in var_205 {
{
let mut object_208 = array_206.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_208, item_207)?;
object_208.finish();
}
}
array_206.finish();
}
if let Some(var_209) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_209).into()),
);
}
if let Some(var_210) = &input.next_token {
object.key("nextToken").string(var_210);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_component_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutComponentPolicyInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_211) = &input.component_arn {
object.key("componentArn").string(var_211);
}
if let Some(var_212) = &input.policy {
object.key("policy").string(var_212);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_container_recipe_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutContainerRecipePolicyInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_213) = &input.container_recipe_arn {
object.key("containerRecipeArn").string(var_213);
}
if let Some(var_214) = &input.policy {
object.key("policy").string(var_214);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_image_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutImagePolicyInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_215) = &input.image_arn {
object.key("imageArn").string(var_215);
}
if let Some(var_216) = &input.policy {
object.key("policy").string(var_216);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_image_recipe_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutImageRecipePolicyInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_217) = &input.image_recipe_arn {
object.key("imageRecipeArn").string(var_217);
}
if let Some(var_218) = &input.policy {
object.key("policy").string(var_218);
}
Ok(())
}
pub fn serialize_structure_crate_input_start_image_pipeline_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartImagePipelineExecutionInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_219) = &input.client_token {
object.key("clientToken").string(var_219);
}
if let Some(var_220) = &input.image_pipeline_arn {
object.key("imagePipelineArn").string(var_220);
}
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_221) = &input.tags {
let mut object_222 = object.key("tags").start_object();
for (key_223, value_224) in var_221 {
{
object_222.key(key_223).string(value_224);
}
}
object_222.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_distribution_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDistributionConfigurationInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_225) = &input.client_token {
object.key("clientToken").string(var_225);
}
if let Some(var_226) = &input.description {
object.key("description").string(var_226);
}
if let Some(var_227) = &input.distribution_configuration_arn {
object.key("distributionConfigurationArn").string(var_227);
}
if let Some(var_228) = &input.distributions {
let mut array_229 = object.key("distributions").start_array();
for item_230 in var_228 {
{
let mut object_231 = array_229.value().start_object();
crate::json_ser::serialize_structure_crate_model_distribution(
&mut object_231,
item_230,
)?;
object_231.finish();
}
}
array_229.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_image_pipeline_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateImagePipelineInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_232) = &input.client_token {
object.key("clientToken").string(var_232);
}
if let Some(var_233) = &input.container_recipe_arn {
object.key("containerRecipeArn").string(var_233);
}
if let Some(var_234) = &input.description {
object.key("description").string(var_234);
}
if let Some(var_235) = &input.distribution_configuration_arn {
object.key("distributionConfigurationArn").string(var_235);
}
if let Some(var_236) = &input.enhanced_image_metadata_enabled {
object.key("enhancedImageMetadataEnabled").boolean(*var_236);
}
if let Some(var_237) = &input.image_pipeline_arn {
object.key("imagePipelineArn").string(var_237);
}
if let Some(var_238) = &input.image_recipe_arn {
object.key("imageRecipeArn").string(var_238);
}
if let Some(var_239) = &input.image_tests_configuration {
let mut object_240 = object.key("imageTestsConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_image_tests_configuration(
&mut object_240,
var_239,
)?;
object_240.finish();
}
if let Some(var_241) = &input.infrastructure_configuration_arn {
object.key("infrastructureConfigurationArn").string(var_241);
}
if let Some(var_242) = &input.schedule {
let mut object_243 = object.key("schedule").start_object();
crate::json_ser::serialize_structure_crate_model_schedule(&mut object_243, var_242)?;
object_243.finish();
}
if let Some(var_244) = &input.status {
object.key("status").string(var_244.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_infrastructure_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateInfrastructureConfigurationInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_245) = &input.client_token {
object.key("clientToken").string(var_245);
}
if let Some(var_246) = &input.description {
object.key("description").string(var_246);
}
if let Some(var_247) = &input.infrastructure_configuration_arn {
object.key("infrastructureConfigurationArn").string(var_247);
}
if let Some(var_248) = &input.instance_metadata_options {
let mut object_249 = object.key("instanceMetadataOptions").start_object();
crate::json_ser::serialize_structure_crate_model_instance_metadata_options(
&mut object_249,
var_248,
)?;
object_249.finish();
}
if let Some(var_250) = &input.instance_profile_name {
object.key("instanceProfileName").string(var_250);
}
if let Some(var_251) = &input.instance_types {
let mut array_252 = object.key("instanceTypes").start_array();
for item_253 in var_251 {
{
array_252.value().string(item_253);
}
}
array_252.finish();
}
if let Some(var_254) = &input.key_pair {
object.key("keyPair").string(var_254);
}
if let Some(var_255) = &input.logging {
let mut object_256 = object.key("logging").start_object();
crate::json_ser::serialize_structure_crate_model_logging(&mut object_256, var_255)?;
object_256.finish();
}
if let Some(var_257) = &input.resource_tags {
let mut object_258 = object.key("resourceTags").start_object();
for (key_259, value_260) in var_257 {
{
object_258.key(key_259).string(value_260);
}
}
object_258.finish();
}
if let Some(var_261) = &input.security_group_ids {
let mut array_262 = object.key("securityGroupIds").start_array();
for item_263 in var_261 {
{
array_262.value().string(item_263);
}
}
array_262.finish();
}
if let Some(var_264) = &input.sns_topic_arn {
object.key("snsTopicArn").string(var_264);
}
if let Some(var_265) = &input.subnet_id {
object.key("subnetId").string(var_265);
}
if let Some(var_266) = &input.terminate_instance_on_failure {
object.key("terminateInstanceOnFailure").boolean(*var_266);
}
Ok(())
}
pub fn serialize_structure_crate_model_component_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComponentConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_267) = &input.component_arn {
object.key("componentArn").string(var_267);
}
if let Some(var_268) = &input.parameters {
let mut array_269 = object.key("parameters").start_array();
for item_270 in var_268 {
{
let mut object_271 = array_269.value().start_object();
crate::json_ser::serialize_structure_crate_model_component_parameter(
&mut object_271,
item_270,
)?;
object_271.finish();
}
}
array_269.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_instance_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InstanceConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_272) = &input.image {
object.key("image").string(var_272);
}
if let Some(var_273) = &input.block_device_mappings {
let mut array_274 = object.key("blockDeviceMappings").start_array();
for item_275 in var_273 {
{
let mut object_276 = array_274.value().start_object();
crate::json_ser::serialize_structure_crate_model_instance_block_device_mapping(
&mut object_276,
item_275,
)?;
object_276.finish();
}
}
array_274.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_target_container_repository(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TargetContainerRepository,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_277) = &input.service {
object.key("service").string(var_277.as_str());
}
if let Some(var_278) = &input.repository_name {
object.key("repositoryName").string(var_278);
}
Ok(())
}
pub fn serialize_structure_crate_model_distribution(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Distribution,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_279) = &input.region {
object.key("region").string(var_279);
}
if let Some(var_280) = &input.ami_distribution_configuration {
let mut object_281 = object.key("amiDistributionConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_ami_distribution_configuration(
&mut object_281,
var_280,
)?;
object_281.finish();
}
if let Some(var_282) = &input.container_distribution_configuration {
let mut object_283 = object
.key("containerDistributionConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_container_distribution_configuration(
&mut object_283,
var_282,
)?;
object_283.finish();
}
if let Some(var_284) = &input.license_configuration_arns {
let mut array_285 = object.key("licenseConfigurationArns").start_array();
for item_286 in var_284 {
{
array_285.value().string(item_286);
}
}
array_285.finish();
}
if let Some(var_287) = &input.launch_template_configurations {
let mut array_288 = object.key("launchTemplateConfigurations").start_array();
for item_289 in var_287 {
{
let mut object_290 = array_288.value().start_object();
crate::json_ser::serialize_structure_crate_model_launch_template_configuration(
&mut object_290,
item_289,
)?;
object_290.finish();
}
}
array_288.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_image_tests_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ImageTestsConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_291) = &input.image_tests_enabled {
object.key("imageTestsEnabled").boolean(*var_291);
}
if let Some(var_292) = &input.timeout_minutes {
object.key("timeoutMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_292).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_schedule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Schedule,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_293) = &input.schedule_expression {
object.key("scheduleExpression").string(var_293);
}
if let Some(var_294) = &input.timezone {
object.key("timezone").string(var_294);
}
if let Some(var_295) = &input.pipeline_execution_start_condition {
object
.key("pipelineExecutionStartCondition")
.string(var_295.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_additional_instance_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AdditionalInstanceConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_296) = &input.systems_manager_agent {
let mut object_297 = object.key("systemsManagerAgent").start_object();
crate::json_ser::serialize_structure_crate_model_systems_manager_agent(
&mut object_297,
var_296,
)?;
object_297.finish();
}
if let Some(var_298) = &input.user_data_override {
object.key("userDataOverride").string(var_298);
}
Ok(())
}
pub fn serialize_structure_crate_model_instance_block_device_mapping(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InstanceBlockDeviceMapping,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_299) = &input.device_name {
object.key("deviceName").string(var_299);
}
if let Some(var_300) = &input.ebs {
let mut object_301 = object.key("ebs").start_object();
crate::json_ser::serialize_structure_crate_model_ebs_instance_block_device_specification(
&mut object_301,
var_300,
)?;
object_301.finish();
}
if let Some(var_302) = &input.virtual_name {
object.key("virtualName").string(var_302);
}
if let Some(var_303) = &input.no_device {
object.key("noDevice").string(var_303);
}
Ok(())
}
pub fn serialize_structure_crate_model_instance_metadata_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InstanceMetadataOptions,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_304) = &input.http_tokens {
object.key("httpTokens").string(var_304);
}
if let Some(var_305) = &input.http_put_response_hop_limit {
object.key("httpPutResponseHopLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_305).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_logging(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Logging,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_306) = &input.s3_logs {
let mut object_307 = object.key("s3Logs").start_object();
crate::json_ser::serialize_structure_crate_model_s3_logs(&mut object_307, var_306)?;
object_307.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Filter,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_308) = &input.name {
object.key("name").string(var_308);
}
if let Some(var_309) = &input.values {
let mut array_310 = object.key("values").start_array();
for item_311 in var_309 {
{
array_310.value().string(item_311);
}
}
array_310.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_component_parameter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComponentParameter,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_312) = &input.name {
object.key("name").string(var_312);
}
if let Some(var_313) = &input.value {
let mut array_314 = object.key("value").start_array();
for item_315 in var_313 {
{
array_314.value().string(item_315);
}
}
array_314.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_ami_distribution_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AmiDistributionConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_316) = &input.name {
object.key("name").string(var_316);
}
if let Some(var_317) = &input.description {
object.key("description").string(var_317);
}
if let Some(var_318) = &input.target_account_ids {
let mut array_319 = object.key("targetAccountIds").start_array();
for item_320 in var_318 {
{
array_319.value().string(item_320);
}
}
array_319.finish();
}
if let Some(var_321) = &input.ami_tags {
let mut object_322 = object.key("amiTags").start_object();
for (key_323, value_324) in var_321 {
{
object_322.key(key_323).string(value_324);
}
}
object_322.finish();
}
if let Some(var_325) = &input.kms_key_id {
object.key("kmsKeyId").string(var_325);
}
if let Some(var_326) = &input.launch_permission {
let mut object_327 = object.key("launchPermission").start_object();
crate::json_ser::serialize_structure_crate_model_launch_permission_configuration(
&mut object_327,
var_326,
)?;
object_327.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_container_distribution_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ContainerDistributionConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_328) = &input.description {
object.key("description").string(var_328);
}
if let Some(var_329) = &input.container_tags {
let mut array_330 = object.key("containerTags").start_array();
for item_331 in var_329 {
{
array_330.value().string(item_331);
}
}
array_330.finish();
}
if let Some(var_332) = &input.target_repository {
let mut object_333 = object.key("targetRepository").start_object();
crate::json_ser::serialize_structure_crate_model_target_container_repository(
&mut object_333,
var_332,
)?;
object_333.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_launch_template_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LaunchTemplateConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_334) = &input.launch_template_id {
object.key("launchTemplateId").string(var_334);
}
if let Some(var_335) = &input.account_id {
object.key("accountId").string(var_335);
}
if input.set_default_version {
object
.key("setDefaultVersion")
.boolean(input.set_default_version);
}
Ok(())
}
pub fn serialize_structure_crate_model_systems_manager_agent(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SystemsManagerAgent,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_336) = &input.uninstall_after_build {
object.key("uninstallAfterBuild").boolean(*var_336);
}
Ok(())
}
pub fn serialize_structure_crate_model_ebs_instance_block_device_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EbsInstanceBlockDeviceSpecification,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_337) = &input.encrypted {
object.key("encrypted").boolean(*var_337);
}
if let Some(var_338) = &input.delete_on_termination {
object.key("deleteOnTermination").boolean(*var_338);
}
if let Some(var_339) = &input.iops {
object.key("iops").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_339).into()),
);
}
if let Some(var_340) = &input.kms_key_id {
object.key("kmsKeyId").string(var_340);
}
if let Some(var_341) = &input.snapshot_id {
object.key("snapshotId").string(var_341);
}
if let Some(var_342) = &input.volume_size {
object.key("volumeSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_342).into()),
);
}
if let Some(var_343) = &input.volume_type {
object.key("volumeType").string(var_343.as_str());
}
if let Some(var_344) = &input.throughput {
object.key("throughput").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_344).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_logs(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3Logs,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_345) = &input.s3_bucket_name {
object.key("s3BucketName").string(var_345);
}
if let Some(var_346) = &input.s3_key_prefix {
object.key("s3KeyPrefix").string(var_346);
}
Ok(())
}
pub fn serialize_structure_crate_model_launch_permission_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LaunchPermissionConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_347) = &input.user_ids {
let mut array_348 = object.key("userIds").start_array();
for item_349 in var_347 {
{
array_348.value().string(item_349);
}
}
array_348.finish();
}
if let Some(var_350) = &input.user_groups {
let mut array_351 = object.key("userGroups").start_array();
for item_352 in var_350 {
{
array_351.value().string(item_352);
}
}
array_351.finish();
}
Ok(())
}