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::error::SerializationError> {
if let Some(var_1) = &input.client_token {
object.key("clientToken").string(var_1.as_str());
}
if let Some(var_2) = &input.image_build_version_arn {
object.key("imageBuildVersionArn").string(var_2.as_str());
}
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::error::SerializationError> {
if let Some(var_3) = &input.change_description {
object.key("changeDescription").string(var_3.as_str());
}
if let Some(var_4) = &input.client_token {
object.key("clientToken").string(var_4.as_str());
}
if let Some(var_5) = &input.data {
object.key("data").string(var_5.as_str());
}
if let Some(var_6) = &input.description {
object.key("description").string(var_6.as_str());
}
if let Some(var_7) = &input.kms_key_id {
object.key("kmsKeyId").string(var_7.as_str());
}
if let Some(var_8) = &input.name {
object.key("name").string(var_8.as_str());
}
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.as_str());
}
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.as_str());
}
}
array_12.finish();
}
if let Some(var_14) = &input.tags {
#[allow(unused_mut)]
let mut object_15 = object.key("tags").start_object();
for (key_16, value_17) in var_14 {
{
object_15.key(key_16.as_str()).string(value_17.as_str());
}
}
object_15.finish();
}
if let Some(var_18) = &input.uri {
object.key("uri").string(var_18.as_str());
}
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::error::SerializationError> {
if let Some(var_19) = &input.client_token {
object.key("clientToken").string(var_19.as_str());
}
if let Some(var_20) = &input.components {
let mut array_21 = object.key("components").start_array();
for item_22 in var_20 {
{
#[allow(unused_mut)]
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.as_str());
}
if let Some(var_26) = &input.dockerfile_template_data {
object.key("dockerfileTemplateData").string(var_26.as_str());
}
if let Some(var_27) = &input.dockerfile_template_uri {
object.key("dockerfileTemplateUri").string(var_27.as_str());
}
if let Some(var_28) = &input.image_os_version_override {
object.key("imageOsVersionOverride").string(var_28.as_str());
}
if let Some(var_29) = &input.instance_configuration {
#[allow(unused_mut)]
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.as_str());
}
if let Some(var_32) = &input.name {
object.key("name").string(var_32.as_str());
}
if let Some(var_33) = &input.parent_image {
object.key("parentImage").string(var_33.as_str());
}
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.as_str());
}
if let Some(var_36) = &input.tags {
#[allow(unused_mut)]
let mut object_37 = object.key("tags").start_object();
for (key_38, value_39) in var_36 {
{
object_37.key(key_38.as_str()).string(value_39.as_str());
}
}
object_37.finish();
}
if let Some(var_40) = &input.target_repository {
#[allow(unused_mut)]
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.as_str());
}
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::error::SerializationError> {
if let Some(var_43) = &input.client_token {
object.key("clientToken").string(var_43.as_str());
}
if let Some(var_44) = &input.description {
object.key("description").string(var_44.as_str());
}
if let Some(var_45) = &input.distributions {
let mut array_46 = object.key("distributions").start_array();
for item_47 in var_45 {
{
#[allow(unused_mut)]
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.as_str());
}
if let Some(var_50) = &input.tags {
#[allow(unused_mut)]
let mut object_51 = object.key("tags").start_object();
for (key_52, value_53) in var_50 {
{
object_51.key(key_52.as_str()).string(value_53.as_str());
}
}
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::error::SerializationError> {
if let Some(var_54) = &input.client_token {
object.key("clientToken").string(var_54.as_str());
}
if let Some(var_55) = &input.container_recipe_arn {
object.key("containerRecipeArn").string(var_55.as_str());
}
if let Some(var_56) = &input.distribution_configuration_arn {
object
.key("distributionConfigurationArn")
.string(var_56.as_str());
}
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.as_str());
}
if let Some(var_59) = &input.image_tests_configuration {
#[allow(unused_mut)]
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.as_str());
}
if let Some(var_62) = &input.tags {
#[allow(unused_mut)]
let mut object_63 = object.key("tags").start_object();
for (key_64, value_65) in var_62 {
{
object_63.key(key_64.as_str()).string(value_65.as_str());
}
}
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::error::SerializationError> {
if let Some(var_66) = &input.client_token {
object.key("clientToken").string(var_66.as_str());
}
if let Some(var_67) = &input.container_recipe_arn {
object.key("containerRecipeArn").string(var_67.as_str());
}
if let Some(var_68) = &input.description {
object.key("description").string(var_68.as_str());
}
if let Some(var_69) = &input.distribution_configuration_arn {
object
.key("distributionConfigurationArn")
.string(var_69.as_str());
}
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.as_str());
}
if let Some(var_72) = &input.image_tests_configuration {
#[allow(unused_mut)]
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.as_str());
}
if let Some(var_75) = &input.name {
object.key("name").string(var_75.as_str());
}
if let Some(var_76) = &input.schedule {
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
let mut object_80 = object.key("tags").start_object();
for (key_81, value_82) in var_79 {
{
object_80.key(key_81.as_str()).string(value_82.as_str());
}
}
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::error::SerializationError> {
if let Some(var_83) = &input.additional_instance_configuration {
#[allow(unused_mut)]
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 {
{
#[allow(unused_mut)]
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.as_str());
}
if let Some(var_90) = &input.components {
let mut array_91 = object.key("components").start_array();
for item_92 in var_90 {
{
#[allow(unused_mut)]
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.as_str());
}
if let Some(var_95) = &input.name {
object.key("name").string(var_95.as_str());
}
if let Some(var_96) = &input.parent_image {
object.key("parentImage").string(var_96.as_str());
}
if let Some(var_97) = &input.semantic_version {
object.key("semanticVersion").string(var_97.as_str());
}
if let Some(var_98) = &input.tags {
#[allow(unused_mut)]
let mut object_99 = object.key("tags").start_object();
for (key_100, value_101) in var_98 {
{
object_99.key(key_100.as_str()).string(value_101.as_str());
}
}
object_99.finish();
}
if let Some(var_102) = &input.working_directory {
object.key("workingDirectory").string(var_102.as_str());
}
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::error::SerializationError> {
if let Some(var_103) = &input.client_token {
object.key("clientToken").string(var_103.as_str());
}
if let Some(var_104) = &input.description {
object.key("description").string(var_104.as_str());
}
if let Some(var_105) = &input.instance_metadata_options {
#[allow(unused_mut)]
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.as_str());
}
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.as_str());
}
}
array_109.finish();
}
if let Some(var_111) = &input.key_pair {
object.key("keyPair").string(var_111.as_str());
}
if let Some(var_112) = &input.logging {
#[allow(unused_mut)]
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.as_str());
}
if let Some(var_115) = &input.resource_tags {
#[allow(unused_mut)]
let mut object_116 = object.key("resourceTags").start_object();
for (key_117, value_118) in var_115 {
{
object_116.key(key_117.as_str()).string(value_118.as_str());
}
}
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.as_str());
}
}
array_120.finish();
}
if let Some(var_122) = &input.sns_topic_arn {
object.key("snsTopicArn").string(var_122.as_str());
}
if let Some(var_123) = &input.subnet_id {
object.key("subnetId").string(var_123.as_str());
}
if let Some(var_124) = &input.tags {
#[allow(unused_mut)]
let mut object_125 = object.key("tags").start_object();
for (key_126, value_127) in var_124 {
{
object_125.key(key_126.as_str()).string(value_127.as_str());
}
}
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::error::SerializationError> {
if let Some(var_129) = &input.change_description {
object.key("changeDescription").string(var_129.as_str());
}
if let Some(var_130) = &input.client_token {
object.key("clientToken").string(var_130.as_str());
}
if let Some(var_131) = &input.data {
object.key("data").string(var_131.as_str());
}
if let Some(var_132) = &input.description {
object.key("description").string(var_132.as_str());
}
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.as_str());
}
if let Some(var_135) = &input.name {
object.key("name").string(var_135.as_str());
}
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.as_str());
}
if let Some(var_138) = &input.tags {
#[allow(unused_mut)]
let mut object_139 = object.key("tags").start_object();
for (key_140, value_141) in var_138 {
{
object_139.key(key_140.as_str()).string(value_141.as_str());
}
}
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.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_import_vm_image_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ImportVmImageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_144) = &input.client_token {
object.key("clientToken").string(var_144.as_str());
}
if let Some(var_145) = &input.description {
object.key("description").string(var_145.as_str());
}
if let Some(var_146) = &input.name {
object.key("name").string(var_146.as_str());
}
if let Some(var_147) = &input.os_version {
object.key("osVersion").string(var_147.as_str());
}
if let Some(var_148) = &input.platform {
object.key("platform").string(var_148.as_str());
}
if let Some(var_149) = &input.semantic_version {
object.key("semanticVersion").string(var_149.as_str());
}
if let Some(var_150) = &input.tags {
#[allow(unused_mut)]
let mut object_151 = object.key("tags").start_object();
for (key_152, value_153) in var_150 {
{
object_151.key(key_152.as_str()).string(value_153.as_str());
}
}
object_151.finish();
}
if let Some(var_154) = &input.vm_import_task_id {
object.key("vmImportTaskId").string(var_154.as_str());
}
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::error::SerializationError> {
if let Some(var_155) = &input.component_version_arn {
object.key("componentVersionArn").string(var_155.as_str());
}
if let Some(var_156) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_156).into()),
);
}
if let Some(var_157) = &input.next_token {
object.key("nextToken").string(var_157.as_str());
}
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::error::SerializationError> {
if input.by_name {
object.key("byName").boolean(input.by_name);
}
if let Some(var_158) = &input.filters {
let mut array_159 = object.key("filters").start_array();
for item_160 in var_158 {
{
#[allow(unused_mut)]
let mut object_161 = array_159.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_161, item_160)?;
object_161.finish();
}
}
array_159.finish();
}
if let Some(var_162) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_162).into()),
);
}
if let Some(var_163) = &input.next_token {
object.key("nextToken").string(var_163.as_str());
}
if let Some(var_164) = &input.owner {
object.key("owner").string(var_164.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::error::SerializationError> {
if let Some(var_165) = &input.filters {
let mut array_166 = object.key("filters").start_array();
for item_167 in var_165 {
{
#[allow(unused_mut)]
let mut object_168 = array_166.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_168, item_167)?;
object_168.finish();
}
}
array_166.finish();
}
if let Some(var_169) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_169).into()),
);
}
if let Some(var_170) = &input.next_token {
object.key("nextToken").string(var_170.as_str());
}
if let Some(var_171) = &input.owner {
object.key("owner").string(var_171.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::error::SerializationError> {
if let Some(var_172) = &input.filters {
let mut array_173 = object.key("filters").start_array();
for item_174 in var_172 {
{
#[allow(unused_mut)]
let mut object_175 = array_173.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_175, item_174)?;
object_175.finish();
}
}
array_173.finish();
}
if let Some(var_176) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_176).into()),
);
}
if let Some(var_177) = &input.next_token {
object.key("nextToken").string(var_177.as_str());
}
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::error::SerializationError> {
if let Some(var_178) = &input.filters {
let mut array_179 = object.key("filters").start_array();
for item_180 in var_178 {
{
#[allow(unused_mut)]
let mut object_181 = array_179.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_181, item_180)?;
object_181.finish();
}
}
array_179.finish();
}
if let Some(var_182) = &input.image_version_arn {
object.key("imageVersionArn").string(var_182.as_str());
}
if let Some(var_183) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_183).into()),
);
}
if let Some(var_184) = &input.next_token {
object.key("nextToken").string(var_184.as_str());
}
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::error::SerializationError> {
if let Some(var_185) = &input.image_build_version_arn {
object.key("imageBuildVersionArn").string(var_185.as_str());
}
if let Some(var_186) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_186).into()),
);
}
if let Some(var_187) = &input.next_token {
object.key("nextToken").string(var_187.as_str());
}
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::error::SerializationError> {
if let Some(var_188) = &input.filters {
let mut array_189 = object.key("filters").start_array();
for item_190 in var_188 {
{
#[allow(unused_mut)]
let mut object_191 = array_189.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_191, item_190)?;
object_191.finish();
}
}
array_189.finish();
}
if let Some(var_192) = &input.image_pipeline_arn {
object.key("imagePipelineArn").string(var_192.as_str());
}
if let Some(var_193) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_193).into()),
);
}
if let Some(var_194) = &input.next_token {
object.key("nextToken").string(var_194.as_str());
}
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::error::SerializationError> {
if let Some(var_195) = &input.filters {
let mut array_196 = object.key("filters").start_array();
for item_197 in var_195 {
{
#[allow(unused_mut)]
let mut object_198 = array_196.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_198, item_197)?;
object_198.finish();
}
}
array_196.finish();
}
if let Some(var_199) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_199).into()),
);
}
if let Some(var_200) = &input.next_token {
object.key("nextToken").string(var_200.as_str());
}
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::error::SerializationError> {
if let Some(var_201) = &input.filters {
let mut array_202 = object.key("filters").start_array();
for item_203 in var_201 {
{
#[allow(unused_mut)]
let mut object_204 = array_202.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_204, item_203)?;
object_204.finish();
}
}
array_202.finish();
}
if let Some(var_205) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_205).into()),
);
}
if let Some(var_206) = &input.next_token {
object.key("nextToken").string(var_206.as_str());
}
if let Some(var_207) = &input.owner {
object.key("owner").string(var_207.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::error::SerializationError> {
if input.by_name {
object.key("byName").boolean(input.by_name);
}
if let Some(var_208) = &input.filters {
let mut array_209 = object.key("filters").start_array();
for item_210 in var_208 {
{
#[allow(unused_mut)]
let mut object_211 = array_209.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_211, item_210)?;
object_211.finish();
}
}
array_209.finish();
}
if let Some(var_212) = &input.include_deprecated {
object.key("includeDeprecated").boolean(*var_212);
}
if let Some(var_213) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_213).into()),
);
}
if let Some(var_214) = &input.next_token {
object.key("nextToken").string(var_214.as_str());
}
if let Some(var_215) = &input.owner {
object.key("owner").string(var_215.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::error::SerializationError> {
if let Some(var_216) = &input.filters {
let mut array_217 = object.key("filters").start_array();
for item_218 in var_216 {
{
#[allow(unused_mut)]
let mut object_219 = array_217.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_219, item_218)?;
object_219.finish();
}
}
array_217.finish();
}
if let Some(var_220) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_220).into()),
);
}
if let Some(var_221) = &input.next_token {
object.key("nextToken").string(var_221.as_str());
}
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::error::SerializationError> {
if let Some(var_222) = &input.component_arn {
object.key("componentArn").string(var_222.as_str());
}
if let Some(var_223) = &input.policy {
object.key("policy").string(var_223.as_str());
}
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::error::SerializationError> {
if let Some(var_224) = &input.container_recipe_arn {
object.key("containerRecipeArn").string(var_224.as_str());
}
if let Some(var_225) = &input.policy {
object.key("policy").string(var_225.as_str());
}
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::error::SerializationError> {
if let Some(var_226) = &input.image_arn {
object.key("imageArn").string(var_226.as_str());
}
if let Some(var_227) = &input.policy {
object.key("policy").string(var_227.as_str());
}
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::error::SerializationError> {
if let Some(var_228) = &input.image_recipe_arn {
object.key("imageRecipeArn").string(var_228.as_str());
}
if let Some(var_229) = &input.policy {
object.key("policy").string(var_229.as_str());
}
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::error::SerializationError> {
if let Some(var_230) = &input.client_token {
object.key("clientToken").string(var_230.as_str());
}
if let Some(var_231) = &input.image_pipeline_arn {
object.key("imagePipelineArn").string(var_231.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_232) = &input.tags {
#[allow(unused_mut)]
let mut object_233 = object.key("tags").start_object();
for (key_234, value_235) in var_232 {
{
object_233.key(key_234.as_str()).string(value_235.as_str());
}
}
object_233.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::error::SerializationError> {
if let Some(var_236) = &input.client_token {
object.key("clientToken").string(var_236.as_str());
}
if let Some(var_237) = &input.description {
object.key("description").string(var_237.as_str());
}
if let Some(var_238) = &input.distribution_configuration_arn {
object
.key("distributionConfigurationArn")
.string(var_238.as_str());
}
if let Some(var_239) = &input.distributions {
let mut array_240 = object.key("distributions").start_array();
for item_241 in var_239 {
{
#[allow(unused_mut)]
let mut object_242 = array_240.value().start_object();
crate::json_ser::serialize_structure_crate_model_distribution(
&mut object_242,
item_241,
)?;
object_242.finish();
}
}
array_240.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::error::SerializationError> {
if let Some(var_243) = &input.client_token {
object.key("clientToken").string(var_243.as_str());
}
if let Some(var_244) = &input.container_recipe_arn {
object.key("containerRecipeArn").string(var_244.as_str());
}
if let Some(var_245) = &input.description {
object.key("description").string(var_245.as_str());
}
if let Some(var_246) = &input.distribution_configuration_arn {
object
.key("distributionConfigurationArn")
.string(var_246.as_str());
}
if let Some(var_247) = &input.enhanced_image_metadata_enabled {
object.key("enhancedImageMetadataEnabled").boolean(*var_247);
}
if let Some(var_248) = &input.image_pipeline_arn {
object.key("imagePipelineArn").string(var_248.as_str());
}
if let Some(var_249) = &input.image_recipe_arn {
object.key("imageRecipeArn").string(var_249.as_str());
}
if let Some(var_250) = &input.image_tests_configuration {
#[allow(unused_mut)]
let mut object_251 = object.key("imageTestsConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_image_tests_configuration(
&mut object_251,
var_250,
)?;
object_251.finish();
}
if let Some(var_252) = &input.infrastructure_configuration_arn {
object
.key("infrastructureConfigurationArn")
.string(var_252.as_str());
}
if let Some(var_253) = &input.schedule {
#[allow(unused_mut)]
let mut object_254 = object.key("schedule").start_object();
crate::json_ser::serialize_structure_crate_model_schedule(&mut object_254, var_253)?;
object_254.finish();
}
if let Some(var_255) = &input.status {
object.key("status").string(var_255.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::error::SerializationError> {
if let Some(var_256) = &input.client_token {
object.key("clientToken").string(var_256.as_str());
}
if let Some(var_257) = &input.description {
object.key("description").string(var_257.as_str());
}
if let Some(var_258) = &input.infrastructure_configuration_arn {
object
.key("infrastructureConfigurationArn")
.string(var_258.as_str());
}
if let Some(var_259) = &input.instance_metadata_options {
#[allow(unused_mut)]
let mut object_260 = object.key("instanceMetadataOptions").start_object();
crate::json_ser::serialize_structure_crate_model_instance_metadata_options(
&mut object_260,
var_259,
)?;
object_260.finish();
}
if let Some(var_261) = &input.instance_profile_name {
object.key("instanceProfileName").string(var_261.as_str());
}
if let Some(var_262) = &input.instance_types {
let mut array_263 = object.key("instanceTypes").start_array();
for item_264 in var_262 {
{
array_263.value().string(item_264.as_str());
}
}
array_263.finish();
}
if let Some(var_265) = &input.key_pair {
object.key("keyPair").string(var_265.as_str());
}
if let Some(var_266) = &input.logging {
#[allow(unused_mut)]
let mut object_267 = object.key("logging").start_object();
crate::json_ser::serialize_structure_crate_model_logging(&mut object_267, var_266)?;
object_267.finish();
}
if let Some(var_268) = &input.resource_tags {
#[allow(unused_mut)]
let mut object_269 = object.key("resourceTags").start_object();
for (key_270, value_271) in var_268 {
{
object_269.key(key_270.as_str()).string(value_271.as_str());
}
}
object_269.finish();
}
if let Some(var_272) = &input.security_group_ids {
let mut array_273 = object.key("securityGroupIds").start_array();
for item_274 in var_272 {
{
array_273.value().string(item_274.as_str());
}
}
array_273.finish();
}
if let Some(var_275) = &input.sns_topic_arn {
object.key("snsTopicArn").string(var_275.as_str());
}
if let Some(var_276) = &input.subnet_id {
object.key("subnetId").string(var_276.as_str());
}
if let Some(var_277) = &input.terminate_instance_on_failure {
object.key("terminateInstanceOnFailure").boolean(*var_277);
}
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::error::SerializationError> {
if let Some(var_278) = &input.component_arn {
object.key("componentArn").string(var_278.as_str());
}
if let Some(var_279) = &input.parameters {
let mut array_280 = object.key("parameters").start_array();
for item_281 in var_279 {
{
#[allow(unused_mut)]
let mut object_282 = array_280.value().start_object();
crate::json_ser::serialize_structure_crate_model_component_parameter(
&mut object_282,
item_281,
)?;
object_282.finish();
}
}
array_280.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::error::SerializationError> {
if let Some(var_283) = &input.image {
object.key("image").string(var_283.as_str());
}
if let Some(var_284) = &input.block_device_mappings {
let mut array_285 = object.key("blockDeviceMappings").start_array();
for item_286 in var_284 {
{
#[allow(unused_mut)]
let mut object_287 = array_285.value().start_object();
crate::json_ser::serialize_structure_crate_model_instance_block_device_mapping(
&mut object_287,
item_286,
)?;
object_287.finish();
}
}
array_285.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::error::SerializationError> {
if let Some(var_288) = &input.service {
object.key("service").string(var_288.as_str());
}
if let Some(var_289) = &input.repository_name {
object.key("repositoryName").string(var_289.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_distribution(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Distribution,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_290) = &input.region {
object.key("region").string(var_290.as_str());
}
if let Some(var_291) = &input.ami_distribution_configuration {
#[allow(unused_mut)]
let mut object_292 = object.key("amiDistributionConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_ami_distribution_configuration(
&mut object_292,
var_291,
)?;
object_292.finish();
}
if let Some(var_293) = &input.container_distribution_configuration {
#[allow(unused_mut)]
let mut object_294 = object
.key("containerDistributionConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_container_distribution_configuration(
&mut object_294,
var_293,
)?;
object_294.finish();
}
if let Some(var_295) = &input.license_configuration_arns {
let mut array_296 = object.key("licenseConfigurationArns").start_array();
for item_297 in var_295 {
{
array_296.value().string(item_297.as_str());
}
}
array_296.finish();
}
if let Some(var_298) = &input.launch_template_configurations {
let mut array_299 = object.key("launchTemplateConfigurations").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_launch_template_configuration(
&mut object_301,
item_300,
)?;
object_301.finish();
}
}
array_299.finish();
}
if let Some(var_302) = &input.s3_export_configuration {
#[allow(unused_mut)]
let mut object_303 = object.key("s3ExportConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_s3_export_configuration(
&mut object_303,
var_302,
)?;
object_303.finish();
}
if let Some(var_304) = &input.fast_launch_configurations {
let mut array_305 = object.key("fastLaunchConfigurations").start_array();
for item_306 in var_304 {
{
#[allow(unused_mut)]
let mut object_307 = array_305.value().start_object();
crate::json_ser::serialize_structure_crate_model_fast_launch_configuration(
&mut object_307,
item_306,
)?;
object_307.finish();
}
}
array_305.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::error::SerializationError> {
if let Some(var_308) = &input.image_tests_enabled {
object.key("imageTestsEnabled").boolean(*var_308);
}
if let Some(var_309) = &input.timeout_minutes {
object.key("timeoutMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_309).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::error::SerializationError> {
if let Some(var_310) = &input.schedule_expression {
object.key("scheduleExpression").string(var_310.as_str());
}
if let Some(var_311) = &input.timezone {
object.key("timezone").string(var_311.as_str());
}
if let Some(var_312) = &input.pipeline_execution_start_condition {
object
.key("pipelineExecutionStartCondition")
.string(var_312.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::error::SerializationError> {
if let Some(var_313) = &input.systems_manager_agent {
#[allow(unused_mut)]
let mut object_314 = object.key("systemsManagerAgent").start_object();
crate::json_ser::serialize_structure_crate_model_systems_manager_agent(
&mut object_314,
var_313,
)?;
object_314.finish();
}
if let Some(var_315) = &input.user_data_override {
object.key("userDataOverride").string(var_315.as_str());
}
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::error::SerializationError> {
if let Some(var_316) = &input.device_name {
object.key("deviceName").string(var_316.as_str());
}
if let Some(var_317) = &input.ebs {
#[allow(unused_mut)]
let mut object_318 = object.key("ebs").start_object();
crate::json_ser::serialize_structure_crate_model_ebs_instance_block_device_specification(
&mut object_318,
var_317,
)?;
object_318.finish();
}
if let Some(var_319) = &input.virtual_name {
object.key("virtualName").string(var_319.as_str());
}
if let Some(var_320) = &input.no_device {
object.key("noDevice").string(var_320.as_str());
}
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::error::SerializationError> {
if let Some(var_321) = &input.http_tokens {
object.key("httpTokens").string(var_321.as_str());
}
if let Some(var_322) = &input.http_put_response_hop_limit {
object.key("httpPutResponseHopLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_322).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::error::SerializationError> {
if let Some(var_323) = &input.s3_logs {
#[allow(unused_mut)]
let mut object_324 = object.key("s3Logs").start_object();
crate::json_ser::serialize_structure_crate_model_s3_logs(&mut object_324, var_323)?;
object_324.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::error::SerializationError> {
if let Some(var_325) = &input.name {
object.key("name").string(var_325.as_str());
}
if let Some(var_326) = &input.values {
let mut array_327 = object.key("values").start_array();
for item_328 in var_326 {
{
array_327.value().string(item_328.as_str());
}
}
array_327.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::error::SerializationError> {
if let Some(var_329) = &input.name {
object.key("name").string(var_329.as_str());
}
if let Some(var_330) = &input.value {
let mut array_331 = object.key("value").start_array();
for item_332 in var_330 {
{
array_331.value().string(item_332.as_str());
}
}
array_331.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::error::SerializationError> {
if let Some(var_333) = &input.name {
object.key("name").string(var_333.as_str());
}
if let Some(var_334) = &input.description {
object.key("description").string(var_334.as_str());
}
if let Some(var_335) = &input.target_account_ids {
let mut array_336 = object.key("targetAccountIds").start_array();
for item_337 in var_335 {
{
array_336.value().string(item_337.as_str());
}
}
array_336.finish();
}
if let Some(var_338) = &input.ami_tags {
#[allow(unused_mut)]
let mut object_339 = object.key("amiTags").start_object();
for (key_340, value_341) in var_338 {
{
object_339.key(key_340.as_str()).string(value_341.as_str());
}
}
object_339.finish();
}
if let Some(var_342) = &input.kms_key_id {
object.key("kmsKeyId").string(var_342.as_str());
}
if let Some(var_343) = &input.launch_permission {
#[allow(unused_mut)]
let mut object_344 = object.key("launchPermission").start_object();
crate::json_ser::serialize_structure_crate_model_launch_permission_configuration(
&mut object_344,
var_343,
)?;
object_344.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::error::SerializationError> {
if let Some(var_345) = &input.description {
object.key("description").string(var_345.as_str());
}
if let Some(var_346) = &input.container_tags {
let mut array_347 = object.key("containerTags").start_array();
for item_348 in var_346 {
{
array_347.value().string(item_348.as_str());
}
}
array_347.finish();
}
if let Some(var_349) = &input.target_repository {
#[allow(unused_mut)]
let mut object_350 = object.key("targetRepository").start_object();
crate::json_ser::serialize_structure_crate_model_target_container_repository(
&mut object_350,
var_349,
)?;
object_350.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::error::SerializationError> {
if let Some(var_351) = &input.launch_template_id {
object.key("launchTemplateId").string(var_351.as_str());
}
if let Some(var_352) = &input.account_id {
object.key("accountId").string(var_352.as_str());
}
if input.set_default_version {
object
.key("setDefaultVersion")
.boolean(input.set_default_version);
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_export_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3ExportConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_353) = &input.role_name {
object.key("roleName").string(var_353.as_str());
}
if let Some(var_354) = &input.disk_image_format {
object.key("diskImageFormat").string(var_354.as_str());
}
if let Some(var_355) = &input.s3_bucket {
object.key("s3Bucket").string(var_355.as_str());
}
if let Some(var_356) = &input.s3_prefix {
object.key("s3Prefix").string(var_356.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_fast_launch_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FastLaunchConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("enabled").boolean(input.enabled);
}
if let Some(var_357) = &input.snapshot_configuration {
#[allow(unused_mut)]
let mut object_358 = object.key("snapshotConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_fast_launch_snapshot_configuration(
&mut object_358,
var_357,
)?;
object_358.finish();
}
if let Some(var_359) = &input.max_parallel_launches {
object.key("maxParallelLaunches").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_359).into()),
);
}
if let Some(var_360) = &input.launch_template {
#[allow(unused_mut)]
let mut object_361 = object.key("launchTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_fast_launch_launch_template_specification(
&mut object_361,
var_360,
)?;
object_361.finish();
}
if let Some(var_362) = &input.account_id {
object.key("accountId").string(var_362.as_str());
}
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::error::SerializationError> {
if let Some(var_363) = &input.uninstall_after_build {
object.key("uninstallAfterBuild").boolean(*var_363);
}
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::error::SerializationError> {
if let Some(var_364) = &input.encrypted {
object.key("encrypted").boolean(*var_364);
}
if let Some(var_365) = &input.delete_on_termination {
object.key("deleteOnTermination").boolean(*var_365);
}
if let Some(var_366) = &input.iops {
object.key("iops").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_366).into()),
);
}
if let Some(var_367) = &input.kms_key_id {
object.key("kmsKeyId").string(var_367.as_str());
}
if let Some(var_368) = &input.snapshot_id {
object.key("snapshotId").string(var_368.as_str());
}
if let Some(var_369) = &input.volume_size {
object.key("volumeSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_369).into()),
);
}
if let Some(var_370) = &input.volume_type {
object.key("volumeType").string(var_370.as_str());
}
if let Some(var_371) = &input.throughput {
object.key("throughput").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_371).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::error::SerializationError> {
if let Some(var_372) = &input.s3_bucket_name {
object.key("s3BucketName").string(var_372.as_str());
}
if let Some(var_373) = &input.s3_key_prefix {
object.key("s3KeyPrefix").string(var_373.as_str());
}
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::error::SerializationError> {
if let Some(var_374) = &input.user_ids {
let mut array_375 = object.key("userIds").start_array();
for item_376 in var_374 {
{
array_375.value().string(item_376.as_str());
}
}
array_375.finish();
}
if let Some(var_377) = &input.user_groups {
let mut array_378 = object.key("userGroups").start_array();
for item_379 in var_377 {
{
array_378.value().string(item_379.as_str());
}
}
array_378.finish();
}
if let Some(var_380) = &input.organization_arns {
let mut array_381 = object.key("organizationArns").start_array();
for item_382 in var_380 {
{
array_381.value().string(item_382.as_str());
}
}
array_381.finish();
}
if let Some(var_383) = &input.organizational_unit_arns {
let mut array_384 = object.key("organizationalUnitArns").start_array();
for item_385 in var_383 {
{
array_384.value().string(item_385.as_str());
}
}
array_384.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_fast_launch_snapshot_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FastLaunchSnapshotConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_386) = &input.target_resource_count {
object.key("targetResourceCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_386).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_fast_launch_launch_template_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FastLaunchLaunchTemplateSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_387) = &input.launch_template_id {
object.key("launchTemplateId").string(var_387.as_str());
}
if let Some(var_388) = &input.launch_template_name {
object.key("launchTemplateName").string(var_388.as_str());
}
if let Some(var_389) = &input.launch_template_version {
object.key("launchTemplateVersion").string(var_389.as_str());
}
Ok(())
}