pub fn serialize_structure_crate_input_create_capacity_provider_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateCapacityProviderInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.name {
object.key("name").string(var_1.as_str());
}
if let Some(var_2) = &input.auto_scaling_group_provider {
#[allow(unused_mut)]
let mut object_3 = object.key("autoScalingGroupProvider").start_object();
crate::json_ser::serialize_structure_crate_model_auto_scaling_group_provider(
&mut object_3,
var_2,
)?;
object_3.finish();
}
if let Some(var_4) = &input.tags {
let mut array_5 = object.key("tags").start_array();
for item_6 in var_4 {
{
#[allow(unused_mut)]
let mut object_7 = array_5.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_7, item_6)?;
object_7.finish();
}
}
array_5.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_cluster_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateClusterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_8) = &input.cluster_name {
object.key("clusterName").string(var_8.as_str());
}
if let Some(var_9) = &input.tags {
let mut array_10 = object.key("tags").start_array();
for item_11 in var_9 {
{
#[allow(unused_mut)]
let mut object_12 = array_10.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_12, item_11)?;
object_12.finish();
}
}
array_10.finish();
}
if let Some(var_13) = &input.settings {
let mut array_14 = object.key("settings").start_array();
for item_15 in var_13 {
{
#[allow(unused_mut)]
let mut object_16 = array_14.value().start_object();
crate::json_ser::serialize_structure_crate_model_cluster_setting(
&mut object_16,
item_15,
)?;
object_16.finish();
}
}
array_14.finish();
}
if let Some(var_17) = &input.configuration {
#[allow(unused_mut)]
let mut object_18 = object.key("configuration").start_object();
crate::json_ser::serialize_structure_crate_model_cluster_configuration(
&mut object_18,
var_17,
)?;
object_18.finish();
}
if let Some(var_19) = &input.capacity_providers {
let mut array_20 = object.key("capacityProviders").start_array();
for item_21 in var_19 {
{
array_20.value().string(item_21.as_str());
}
}
array_20.finish();
}
if let Some(var_22) = &input.default_capacity_provider_strategy {
let mut array_23 = object.key("defaultCapacityProviderStrategy").start_array();
for item_24 in var_22 {
{
#[allow(unused_mut)]
let mut object_25 = array_23.value().start_object();
crate::json_ser::serialize_structure_crate_model_capacity_provider_strategy_item(
&mut object_25,
item_24,
)?;
object_25.finish();
}
}
array_23.finish();
}
if let Some(var_26) = &input.service_connect_defaults {
#[allow(unused_mut)]
let mut object_27 = object.key("serviceConnectDefaults").start_object();
crate::json_ser::serialize_structure_crate_model_cluster_service_connect_defaults_request(
&mut object_27,
var_26,
)?;
object_27.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_service_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateServiceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_28) = &input.cluster {
object.key("cluster").string(var_28.as_str());
}
if let Some(var_29) = &input.service_name {
object.key("serviceName").string(var_29.as_str());
}
if let Some(var_30) = &input.task_definition {
object.key("taskDefinition").string(var_30.as_str());
}
if let Some(var_31) = &input.load_balancers {
let mut array_32 = object.key("loadBalancers").start_array();
for item_33 in var_31 {
{
#[allow(unused_mut)]
let mut object_34 = array_32.value().start_object();
crate::json_ser::serialize_structure_crate_model_load_balancer(
&mut object_34,
item_33,
)?;
object_34.finish();
}
}
array_32.finish();
}
if let Some(var_35) = &input.service_registries {
let mut array_36 = object.key("serviceRegistries").start_array();
for item_37 in var_35 {
{
#[allow(unused_mut)]
let mut object_38 = array_36.value().start_object();
crate::json_ser::serialize_structure_crate_model_service_registry(
&mut object_38,
item_37,
)?;
object_38.finish();
}
}
array_36.finish();
}
if let Some(var_39) = &input.desired_count {
object.key("desiredCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_39).into()),
);
}
if let Some(var_40) = &input.client_token {
object.key("clientToken").string(var_40.as_str());
}
if let Some(var_41) = &input.launch_type {
object.key("launchType").string(var_41.as_str());
}
if let Some(var_42) = &input.capacity_provider_strategy {
let mut array_43 = object.key("capacityProviderStrategy").start_array();
for item_44 in var_42 {
{
#[allow(unused_mut)]
let mut object_45 = array_43.value().start_object();
crate::json_ser::serialize_structure_crate_model_capacity_provider_strategy_item(
&mut object_45,
item_44,
)?;
object_45.finish();
}
}
array_43.finish();
}
if let Some(var_46) = &input.platform_version {
object.key("platformVersion").string(var_46.as_str());
}
if let Some(var_47) = &input.role {
object.key("role").string(var_47.as_str());
}
if let Some(var_48) = &input.deployment_configuration {
#[allow(unused_mut)]
let mut object_49 = object.key("deploymentConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_deployment_configuration(
&mut object_49,
var_48,
)?;
object_49.finish();
}
if let Some(var_50) = &input.placement_constraints {
let mut array_51 = object.key("placementConstraints").start_array();
for item_52 in var_50 {
{
#[allow(unused_mut)]
let mut object_53 = array_51.value().start_object();
crate::json_ser::serialize_structure_crate_model_placement_constraint(
&mut object_53,
item_52,
)?;
object_53.finish();
}
}
array_51.finish();
}
if let Some(var_54) = &input.placement_strategy {
let mut array_55 = object.key("placementStrategy").start_array();
for item_56 in var_54 {
{
#[allow(unused_mut)]
let mut object_57 = array_55.value().start_object();
crate::json_ser::serialize_structure_crate_model_placement_strategy(
&mut object_57,
item_56,
)?;
object_57.finish();
}
}
array_55.finish();
}
if let Some(var_58) = &input.network_configuration {
#[allow(unused_mut)]
let mut object_59 = object.key("networkConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_network_configuration(
&mut object_59,
var_58,
)?;
object_59.finish();
}
if let Some(var_60) = &input.health_check_grace_period_seconds {
object.key("healthCheckGracePeriodSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_60).into()),
);
}
if let Some(var_61) = &input.scheduling_strategy {
object.key("schedulingStrategy").string(var_61.as_str());
}
if let Some(var_62) = &input.deployment_controller {
#[allow(unused_mut)]
let mut object_63 = object.key("deploymentController").start_object();
crate::json_ser::serialize_structure_crate_model_deployment_controller(
&mut object_63,
var_62,
)?;
object_63.finish();
}
if let Some(var_64) = &input.tags {
let mut array_65 = object.key("tags").start_array();
for item_66 in var_64 {
{
#[allow(unused_mut)]
let mut object_67 = array_65.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_67, item_66)?;
object_67.finish();
}
}
array_65.finish();
}
if input.enable_ecs_managed_tags {
object
.key("enableECSManagedTags")
.boolean(input.enable_ecs_managed_tags);
}
if let Some(var_68) = &input.propagate_tags {
object.key("propagateTags").string(var_68.as_str());
}
if input.enable_execute_command {
object
.key("enableExecuteCommand")
.boolean(input.enable_execute_command);
}
if let Some(var_69) = &input.service_connect_configuration {
#[allow(unused_mut)]
let mut object_70 = object.key("serviceConnectConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_service_connect_configuration(
&mut object_70,
var_69,
)?;
object_70.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_task_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateTaskSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_71) = &input.service {
object.key("service").string(var_71.as_str());
}
if let Some(var_72) = &input.cluster {
object.key("cluster").string(var_72.as_str());
}
if let Some(var_73) = &input.external_id {
object.key("externalId").string(var_73.as_str());
}
if let Some(var_74) = &input.task_definition {
object.key("taskDefinition").string(var_74.as_str());
}
if let Some(var_75) = &input.network_configuration {
#[allow(unused_mut)]
let mut object_76 = object.key("networkConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_network_configuration(
&mut object_76,
var_75,
)?;
object_76.finish();
}
if let Some(var_77) = &input.load_balancers {
let mut array_78 = object.key("loadBalancers").start_array();
for item_79 in var_77 {
{
#[allow(unused_mut)]
let mut object_80 = array_78.value().start_object();
crate::json_ser::serialize_structure_crate_model_load_balancer(
&mut object_80,
item_79,
)?;
object_80.finish();
}
}
array_78.finish();
}
if let Some(var_81) = &input.service_registries {
let mut array_82 = object.key("serviceRegistries").start_array();
for item_83 in var_81 {
{
#[allow(unused_mut)]
let mut object_84 = array_82.value().start_object();
crate::json_ser::serialize_structure_crate_model_service_registry(
&mut object_84,
item_83,
)?;
object_84.finish();
}
}
array_82.finish();
}
if let Some(var_85) = &input.launch_type {
object.key("launchType").string(var_85.as_str());
}
if let Some(var_86) = &input.capacity_provider_strategy {
let mut array_87 = object.key("capacityProviderStrategy").start_array();
for item_88 in var_86 {
{
#[allow(unused_mut)]
let mut object_89 = array_87.value().start_object();
crate::json_ser::serialize_structure_crate_model_capacity_provider_strategy_item(
&mut object_89,
item_88,
)?;
object_89.finish();
}
}
array_87.finish();
}
if let Some(var_90) = &input.platform_version {
object.key("platformVersion").string(var_90.as_str());
}
if let Some(var_91) = &input.scale {
#[allow(unused_mut)]
let mut object_92 = object.key("scale").start_object();
crate::json_ser::serialize_structure_crate_model_scale(&mut object_92, var_91)?;
object_92.finish();
}
if let Some(var_93) = &input.client_token {
object.key("clientToken").string(var_93.as_str());
}
if let Some(var_94) = &input.tags {
let mut array_95 = object.key("tags").start_array();
for item_96 in var_94 {
{
#[allow(unused_mut)]
let mut object_97 = array_95.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_97, item_96)?;
object_97.finish();
}
}
array_95.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_account_setting_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAccountSettingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_98) = &input.name {
object.key("name").string(var_98.as_str());
}
if let Some(var_99) = &input.principal_arn {
object.key("principalArn").string(var_99.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_attributes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAttributesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_100) = &input.cluster {
object.key("cluster").string(var_100.as_str());
}
if let Some(var_101) = &input.attributes {
let mut array_102 = object.key("attributes").start_array();
for item_103 in var_101 {
{
#[allow(unused_mut)]
let mut object_104 = array_102.value().start_object();
crate::json_ser::serialize_structure_crate_model_attribute(
&mut object_104,
item_103,
)?;
object_104.finish();
}
}
array_102.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_capacity_provider_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteCapacityProviderInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_105) = &input.capacity_provider {
object.key("capacityProvider").string(var_105.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_cluster_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteClusterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_106) = &input.cluster {
object.key("cluster").string(var_106.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_service_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteServiceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_107) = &input.cluster {
object.key("cluster").string(var_107.as_str());
}
if let Some(var_108) = &input.service {
object.key("service").string(var_108.as_str());
}
if let Some(var_109) = &input.force {
object.key("force").boolean(*var_109);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_task_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteTaskSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_110) = &input.cluster {
object.key("cluster").string(var_110.as_str());
}
if let Some(var_111) = &input.service {
object.key("service").string(var_111.as_str());
}
if let Some(var_112) = &input.task_set {
object.key("taskSet").string(var_112.as_str());
}
if let Some(var_113) = &input.force {
object.key("force").boolean(*var_113);
}
Ok(())
}
pub fn serialize_structure_crate_input_deregister_container_instance_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeregisterContainerInstanceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_114) = &input.cluster {
object.key("cluster").string(var_114.as_str());
}
if let Some(var_115) = &input.container_instance {
object.key("containerInstance").string(var_115.as_str());
}
if let Some(var_116) = &input.force {
object.key("force").boolean(*var_116);
}
Ok(())
}
pub fn serialize_structure_crate_input_deregister_task_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeregisterTaskDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_117) = &input.task_definition {
object.key("taskDefinition").string(var_117.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_capacity_providers_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeCapacityProvidersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_118) = &input.capacity_providers {
let mut array_119 = object.key("capacityProviders").start_array();
for item_120 in var_118 {
{
array_119.value().string(item_120.as_str());
}
}
array_119.finish();
}
if let Some(var_121) = &input.include {
let mut array_122 = object.key("include").start_array();
for item_123 in var_121 {
{
array_122.value().string(item_123.as_str());
}
}
array_122.finish();
}
if let Some(var_124) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_124).into()),
);
}
if let Some(var_125) = &input.next_token {
object.key("nextToken").string(var_125.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_clusters_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeClustersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_126) = &input.clusters {
let mut array_127 = object.key("clusters").start_array();
for item_128 in var_126 {
{
array_127.value().string(item_128.as_str());
}
}
array_127.finish();
}
if let Some(var_129) = &input.include {
let mut array_130 = object.key("include").start_array();
for item_131 in var_129 {
{
array_130.value().string(item_131.as_str());
}
}
array_130.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_container_instances_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeContainerInstancesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_132) = &input.cluster {
object.key("cluster").string(var_132.as_str());
}
if let Some(var_133) = &input.container_instances {
let mut array_134 = object.key("containerInstances").start_array();
for item_135 in var_133 {
{
array_134.value().string(item_135.as_str());
}
}
array_134.finish();
}
if let Some(var_136) = &input.include {
let mut array_137 = object.key("include").start_array();
for item_138 in var_136 {
{
array_137.value().string(item_138.as_str());
}
}
array_137.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_services_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeServicesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_139) = &input.cluster {
object.key("cluster").string(var_139.as_str());
}
if let Some(var_140) = &input.services {
let mut array_141 = object.key("services").start_array();
for item_142 in var_140 {
{
array_141.value().string(item_142.as_str());
}
}
array_141.finish();
}
if let Some(var_143) = &input.include {
let mut array_144 = object.key("include").start_array();
for item_145 in var_143 {
{
array_144.value().string(item_145.as_str());
}
}
array_144.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_task_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeTaskDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_146) = &input.task_definition {
object.key("taskDefinition").string(var_146.as_str());
}
if let Some(var_147) = &input.include {
let mut array_148 = object.key("include").start_array();
for item_149 in var_147 {
{
array_148.value().string(item_149.as_str());
}
}
array_148.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_tasks_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeTasksInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_150) = &input.cluster {
object.key("cluster").string(var_150.as_str());
}
if let Some(var_151) = &input.tasks {
let mut array_152 = object.key("tasks").start_array();
for item_153 in var_151 {
{
array_152.value().string(item_153.as_str());
}
}
array_152.finish();
}
if let Some(var_154) = &input.include {
let mut array_155 = object.key("include").start_array();
for item_156 in var_154 {
{
array_155.value().string(item_156.as_str());
}
}
array_155.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_task_sets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeTaskSetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_157) = &input.cluster {
object.key("cluster").string(var_157.as_str());
}
if let Some(var_158) = &input.service {
object.key("service").string(var_158.as_str());
}
if let Some(var_159) = &input.task_sets {
let mut array_160 = object.key("taskSets").start_array();
for item_161 in var_159 {
{
array_160.value().string(item_161.as_str());
}
}
array_160.finish();
}
if let Some(var_162) = &input.include {
let mut array_163 = object.key("include").start_array();
for item_164 in var_162 {
{
array_163.value().string(item_164.as_str());
}
}
array_163.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_discover_poll_endpoint_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DiscoverPollEndpointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_165) = &input.container_instance {
object.key("containerInstance").string(var_165.as_str());
}
if let Some(var_166) = &input.cluster {
object.key("cluster").string(var_166.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_execute_command_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ExecuteCommandInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_167) = &input.cluster {
object.key("cluster").string(var_167.as_str());
}
if let Some(var_168) = &input.container {
object.key("container").string(var_168.as_str());
}
if let Some(var_169) = &input.command {
object.key("command").string(var_169.as_str());
}
{
object.key("interactive").boolean(input.interactive);
}
if let Some(var_170) = &input.task {
object.key("task").string(var_170.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_task_protection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetTaskProtectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_171) = &input.cluster {
object.key("cluster").string(var_171.as_str());
}
if let Some(var_172) = &input.tasks {
let mut array_173 = object.key("tasks").start_array();
for item_174 in var_172 {
{
array_173.value().string(item_174.as_str());
}
}
array_173.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_account_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAccountSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_175) = &input.name {
object.key("name").string(var_175.as_str());
}
if let Some(var_176) = &input.value {
object.key("value").string(var_176.as_str());
}
if let Some(var_177) = &input.principal_arn {
object.key("principalArn").string(var_177.as_str());
}
if input.effective_settings {
object
.key("effectiveSettings")
.boolean(input.effective_settings);
}
if let Some(var_178) = &input.next_token {
object.key("nextToken").string(var_178.as_str());
}
if input.max_results != 0 {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_attributes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAttributesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_179) = &input.cluster {
object.key("cluster").string(var_179.as_str());
}
if let Some(var_180) = &input.target_type {
object.key("targetType").string(var_180.as_str());
}
if let Some(var_181) = &input.attribute_name {
object.key("attributeName").string(var_181.as_str());
}
if let Some(var_182) = &input.attribute_value {
object.key("attributeValue").string(var_182.as_str());
}
if let Some(var_183) = &input.next_token {
object.key("nextToken").string(var_183.as_str());
}
if let Some(var_184) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_184).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_clusters_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListClustersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_185) = &input.next_token {
object.key("nextToken").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()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_container_instances_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListContainerInstancesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_187) = &input.cluster {
object.key("cluster").string(var_187.as_str());
}
if let Some(var_188) = &input.filter {
object.key("filter").string(var_188.as_str());
}
if let Some(var_189) = &input.next_token {
object.key("nextToken").string(var_189.as_str());
}
if let Some(var_190) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_190).into()),
);
}
if let Some(var_191) = &input.status {
object.key("status").string(var_191.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_services_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListServicesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_192) = &input.cluster {
object.key("cluster").string(var_192.as_str());
}
if let Some(var_193) = &input.next_token {
object.key("nextToken").string(var_193.as_str());
}
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.launch_type {
object.key("launchType").string(var_195.as_str());
}
if let Some(var_196) = &input.scheduling_strategy {
object.key("schedulingStrategy").string(var_196.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_services_by_namespace_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListServicesByNamespaceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_197) = &input.namespace {
object.key("namespace").string(var_197.as_str());
}
if let Some(var_198) = &input.next_token {
object.key("nextToken").string(var_198.as_str());
}
if let Some(var_199) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_199).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tags_for_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTagsForResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_200) = &input.resource_arn {
object.key("resourceArn").string(var_200.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_task_definition_families_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTaskDefinitionFamiliesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_201) = &input.family_prefix {
object.key("familyPrefix").string(var_201.as_str());
}
if let Some(var_202) = &input.status {
object.key("status").string(var_202.as_str());
}
if let Some(var_203) = &input.next_token {
object.key("nextToken").string(var_203.as_str());
}
if let Some(var_204) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_204).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_task_definitions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTaskDefinitionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_205) = &input.family_prefix {
object.key("familyPrefix").string(var_205.as_str());
}
if let Some(var_206) = &input.status {
object.key("status").string(var_206.as_str());
}
if let Some(var_207) = &input.sort {
object.key("sort").string(var_207.as_str());
}
if let Some(var_208) = &input.next_token {
object.key("nextToken").string(var_208.as_str());
}
if let Some(var_209) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_209).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tasks_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTasksInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_210) = &input.cluster {
object.key("cluster").string(var_210.as_str());
}
if let Some(var_211) = &input.container_instance {
object.key("containerInstance").string(var_211.as_str());
}
if let Some(var_212) = &input.family {
object.key("family").string(var_212.as_str());
}
if let Some(var_213) = &input.next_token {
object.key("nextToken").string(var_213.as_str());
}
if let Some(var_214) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_214).into()),
);
}
if let Some(var_215) = &input.started_by {
object.key("startedBy").string(var_215.as_str());
}
if let Some(var_216) = &input.service_name {
object.key("serviceName").string(var_216.as_str());
}
if let Some(var_217) = &input.desired_status {
object.key("desiredStatus").string(var_217.as_str());
}
if let Some(var_218) = &input.launch_type {
object.key("launchType").string(var_218.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_account_setting_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutAccountSettingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_219) = &input.name {
object.key("name").string(var_219.as_str());
}
if let Some(var_220) = &input.value {
object.key("value").string(var_220.as_str());
}
if let Some(var_221) = &input.principal_arn {
object.key("principalArn").string(var_221.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_account_setting_default_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutAccountSettingDefaultInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_222) = &input.name {
object.key("name").string(var_222.as_str());
}
if let Some(var_223) = &input.value {
object.key("value").string(var_223.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_attributes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutAttributesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_224) = &input.cluster {
object.key("cluster").string(var_224.as_str());
}
if let Some(var_225) = &input.attributes {
let mut array_226 = object.key("attributes").start_array();
for item_227 in var_225 {
{
#[allow(unused_mut)]
let mut object_228 = array_226.value().start_object();
crate::json_ser::serialize_structure_crate_model_attribute(
&mut object_228,
item_227,
)?;
object_228.finish();
}
}
array_226.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_cluster_capacity_providers_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutClusterCapacityProvidersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_229) = &input.cluster {
object.key("cluster").string(var_229.as_str());
}
if let Some(var_230) = &input.capacity_providers {
let mut array_231 = object.key("capacityProviders").start_array();
for item_232 in var_230 {
{
array_231.value().string(item_232.as_str());
}
}
array_231.finish();
}
if let Some(var_233) = &input.default_capacity_provider_strategy {
let mut array_234 = object.key("defaultCapacityProviderStrategy").start_array();
for item_235 in var_233 {
{
#[allow(unused_mut)]
let mut object_236 = array_234.value().start_object();
crate::json_ser::serialize_structure_crate_model_capacity_provider_strategy_item(
&mut object_236,
item_235,
)?;
object_236.finish();
}
}
array_234.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_register_container_instance_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterContainerInstanceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_237) = &input.cluster {
object.key("cluster").string(var_237.as_str());
}
if let Some(var_238) = &input.instance_identity_document {
object
.key("instanceIdentityDocument")
.string(var_238.as_str());
}
if let Some(var_239) = &input.instance_identity_document_signature {
object
.key("instanceIdentityDocumentSignature")
.string(var_239.as_str());
}
if let Some(var_240) = &input.total_resources {
let mut array_241 = object.key("totalResources").start_array();
for item_242 in var_240 {
{
#[allow(unused_mut)]
let mut object_243 = array_241.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource(
&mut object_243,
item_242,
)?;
object_243.finish();
}
}
array_241.finish();
}
if let Some(var_244) = &input.version_info {
#[allow(unused_mut)]
let mut object_245 = object.key("versionInfo").start_object();
crate::json_ser::serialize_structure_crate_model_version_info(&mut object_245, var_244)?;
object_245.finish();
}
if let Some(var_246) = &input.container_instance_arn {
object.key("containerInstanceArn").string(var_246.as_str());
}
if let Some(var_247) = &input.attributes {
let mut array_248 = object.key("attributes").start_array();
for item_249 in var_247 {
{
#[allow(unused_mut)]
let mut object_250 = array_248.value().start_object();
crate::json_ser::serialize_structure_crate_model_attribute(
&mut object_250,
item_249,
)?;
object_250.finish();
}
}
array_248.finish();
}
if let Some(var_251) = &input.platform_devices {
let mut array_252 = object.key("platformDevices").start_array();
for item_253 in var_251 {
{
#[allow(unused_mut)]
let mut object_254 = array_252.value().start_object();
crate::json_ser::serialize_structure_crate_model_platform_device(
&mut object_254,
item_253,
)?;
object_254.finish();
}
}
array_252.finish();
}
if let Some(var_255) = &input.tags {
let mut array_256 = object.key("tags").start_array();
for item_257 in var_255 {
{
#[allow(unused_mut)]
let mut object_258 = array_256.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_258, item_257)?;
object_258.finish();
}
}
array_256.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_register_task_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterTaskDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_259) = &input.family {
object.key("family").string(var_259.as_str());
}
if let Some(var_260) = &input.task_role_arn {
object.key("taskRoleArn").string(var_260.as_str());
}
if let Some(var_261) = &input.execution_role_arn {
object.key("executionRoleArn").string(var_261.as_str());
}
if let Some(var_262) = &input.network_mode {
object.key("networkMode").string(var_262.as_str());
}
if let Some(var_263) = &input.container_definitions {
let mut array_264 = object.key("containerDefinitions").start_array();
for item_265 in var_263 {
{
#[allow(unused_mut)]
let mut object_266 = array_264.value().start_object();
crate::json_ser::serialize_structure_crate_model_container_definition(
&mut object_266,
item_265,
)?;
object_266.finish();
}
}
array_264.finish();
}
if let Some(var_267) = &input.volumes {
let mut array_268 = object.key("volumes").start_array();
for item_269 in var_267 {
{
#[allow(unused_mut)]
let mut object_270 = array_268.value().start_object();
crate::json_ser::serialize_structure_crate_model_volume(&mut object_270, item_269)?;
object_270.finish();
}
}
array_268.finish();
}
if let Some(var_271) = &input.placement_constraints {
let mut array_272 = object.key("placementConstraints").start_array();
for item_273 in var_271 {
{
#[allow(unused_mut)]
let mut object_274 = array_272.value().start_object();
crate::json_ser::serialize_structure_crate_model_task_definition_placement_constraint(&mut object_274, item_273)?;
object_274.finish();
}
}
array_272.finish();
}
if let Some(var_275) = &input.requires_compatibilities {
let mut array_276 = object.key("requiresCompatibilities").start_array();
for item_277 in var_275 {
{
array_276.value().string(item_277.as_str());
}
}
array_276.finish();
}
if let Some(var_278) = &input.cpu {
object.key("cpu").string(var_278.as_str());
}
if let Some(var_279) = &input.memory {
object.key("memory").string(var_279.as_str());
}
if let Some(var_280) = &input.tags {
let mut array_281 = object.key("tags").start_array();
for item_282 in var_280 {
{
#[allow(unused_mut)]
let mut object_283 = array_281.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_283, item_282)?;
object_283.finish();
}
}
array_281.finish();
}
if let Some(var_284) = &input.pid_mode {
object.key("pidMode").string(var_284.as_str());
}
if let Some(var_285) = &input.ipc_mode {
object.key("ipcMode").string(var_285.as_str());
}
if let Some(var_286) = &input.proxy_configuration {
#[allow(unused_mut)]
let mut object_287 = object.key("proxyConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_proxy_configuration(
&mut object_287,
var_286,
)?;
object_287.finish();
}
if let Some(var_288) = &input.inference_accelerators {
let mut array_289 = object.key("inferenceAccelerators").start_array();
for item_290 in var_288 {
{
#[allow(unused_mut)]
let mut object_291 = array_289.value().start_object();
crate::json_ser::serialize_structure_crate_model_inference_accelerator(
&mut object_291,
item_290,
)?;
object_291.finish();
}
}
array_289.finish();
}
if let Some(var_292) = &input.ephemeral_storage {
#[allow(unused_mut)]
let mut object_293 = object.key("ephemeralStorage").start_object();
crate::json_ser::serialize_structure_crate_model_ephemeral_storage(
&mut object_293,
var_292,
)?;
object_293.finish();
}
if let Some(var_294) = &input.runtime_platform {
#[allow(unused_mut)]
let mut object_295 = object.key("runtimePlatform").start_object();
crate::json_ser::serialize_structure_crate_model_runtime_platform(
&mut object_295,
var_294,
)?;
object_295.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_run_task_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RunTaskInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_296) = &input.capacity_provider_strategy {
let mut array_297 = object.key("capacityProviderStrategy").start_array();
for item_298 in var_296 {
{
#[allow(unused_mut)]
let mut object_299 = array_297.value().start_object();
crate::json_ser::serialize_structure_crate_model_capacity_provider_strategy_item(
&mut object_299,
item_298,
)?;
object_299.finish();
}
}
array_297.finish();
}
if let Some(var_300) = &input.cluster {
object.key("cluster").string(var_300.as_str());
}
if let Some(var_301) = &input.count {
object.key("count").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_301).into()),
);
}
if input.enable_ecs_managed_tags {
object
.key("enableECSManagedTags")
.boolean(input.enable_ecs_managed_tags);
}
if input.enable_execute_command {
object
.key("enableExecuteCommand")
.boolean(input.enable_execute_command);
}
if let Some(var_302) = &input.group {
object.key("group").string(var_302.as_str());
}
if let Some(var_303) = &input.launch_type {
object.key("launchType").string(var_303.as_str());
}
if let Some(var_304) = &input.network_configuration {
#[allow(unused_mut)]
let mut object_305 = object.key("networkConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_network_configuration(
&mut object_305,
var_304,
)?;
object_305.finish();
}
if let Some(var_306) = &input.overrides {
#[allow(unused_mut)]
let mut object_307 = object.key("overrides").start_object();
crate::json_ser::serialize_structure_crate_model_task_override(&mut object_307, var_306)?;
object_307.finish();
}
if let Some(var_308) = &input.placement_constraints {
let mut array_309 = object.key("placementConstraints").start_array();
for item_310 in var_308 {
{
#[allow(unused_mut)]
let mut object_311 = array_309.value().start_object();
crate::json_ser::serialize_structure_crate_model_placement_constraint(
&mut object_311,
item_310,
)?;
object_311.finish();
}
}
array_309.finish();
}
if let Some(var_312) = &input.placement_strategy {
let mut array_313 = object.key("placementStrategy").start_array();
for item_314 in var_312 {
{
#[allow(unused_mut)]
let mut object_315 = array_313.value().start_object();
crate::json_ser::serialize_structure_crate_model_placement_strategy(
&mut object_315,
item_314,
)?;
object_315.finish();
}
}
array_313.finish();
}
if let Some(var_316) = &input.platform_version {
object.key("platformVersion").string(var_316.as_str());
}
if let Some(var_317) = &input.propagate_tags {
object.key("propagateTags").string(var_317.as_str());
}
if let Some(var_318) = &input.reference_id {
object.key("referenceId").string(var_318.as_str());
}
if let Some(var_319) = &input.started_by {
object.key("startedBy").string(var_319.as_str());
}
if let Some(var_320) = &input.tags {
let mut array_321 = object.key("tags").start_array();
for item_322 in var_320 {
{
#[allow(unused_mut)]
let mut object_323 = array_321.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_323, item_322)?;
object_323.finish();
}
}
array_321.finish();
}
if let Some(var_324) = &input.task_definition {
object.key("taskDefinition").string(var_324.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_task_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartTaskInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_325) = &input.cluster {
object.key("cluster").string(var_325.as_str());
}
if let Some(var_326) = &input.container_instances {
let mut array_327 = object.key("containerInstances").start_array();
for item_328 in var_326 {
{
array_327.value().string(item_328.as_str());
}
}
array_327.finish();
}
if input.enable_ecs_managed_tags {
object
.key("enableECSManagedTags")
.boolean(input.enable_ecs_managed_tags);
}
if input.enable_execute_command {
object
.key("enableExecuteCommand")
.boolean(input.enable_execute_command);
}
if let Some(var_329) = &input.group {
object.key("group").string(var_329.as_str());
}
if let Some(var_330) = &input.network_configuration {
#[allow(unused_mut)]
let mut object_331 = object.key("networkConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_network_configuration(
&mut object_331,
var_330,
)?;
object_331.finish();
}
if let Some(var_332) = &input.overrides {
#[allow(unused_mut)]
let mut object_333 = object.key("overrides").start_object();
crate::json_ser::serialize_structure_crate_model_task_override(&mut object_333, var_332)?;
object_333.finish();
}
if let Some(var_334) = &input.propagate_tags {
object.key("propagateTags").string(var_334.as_str());
}
if let Some(var_335) = &input.reference_id {
object.key("referenceId").string(var_335.as_str());
}
if let Some(var_336) = &input.started_by {
object.key("startedBy").string(var_336.as_str());
}
if let Some(var_337) = &input.tags {
let mut array_338 = object.key("tags").start_array();
for item_339 in var_337 {
{
#[allow(unused_mut)]
let mut object_340 = array_338.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_340, item_339)?;
object_340.finish();
}
}
array_338.finish();
}
if let Some(var_341) = &input.task_definition {
object.key("taskDefinition").string(var_341.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_task_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopTaskInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_342) = &input.cluster {
object.key("cluster").string(var_342.as_str());
}
if let Some(var_343) = &input.task {
object.key("task").string(var_343.as_str());
}
if let Some(var_344) = &input.reason {
object.key("reason").string(var_344.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_submit_attachment_state_changes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SubmitAttachmentStateChangesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_345) = &input.cluster {
object.key("cluster").string(var_345.as_str());
}
if let Some(var_346) = &input.attachments {
let mut array_347 = object.key("attachments").start_array();
for item_348 in var_346 {
{
#[allow(unused_mut)]
let mut object_349 = array_347.value().start_object();
crate::json_ser::serialize_structure_crate_model_attachment_state_change(
&mut object_349,
item_348,
)?;
object_349.finish();
}
}
array_347.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_submit_container_state_change_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SubmitContainerStateChangeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_350) = &input.cluster {
object.key("cluster").string(var_350.as_str());
}
if let Some(var_351) = &input.task {
object.key("task").string(var_351.as_str());
}
if let Some(var_352) = &input.container_name {
object.key("containerName").string(var_352.as_str());
}
if let Some(var_353) = &input.runtime_id {
object.key("runtimeId").string(var_353.as_str());
}
if let Some(var_354) = &input.status {
object.key("status").string(var_354.as_str());
}
if let Some(var_355) = &input.exit_code {
object.key("exitCode").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_355).into()),
);
}
if let Some(var_356) = &input.reason {
object.key("reason").string(var_356.as_str());
}
if let Some(var_357) = &input.network_bindings {
let mut array_358 = object.key("networkBindings").start_array();
for item_359 in var_357 {
{
#[allow(unused_mut)]
let mut object_360 = array_358.value().start_object();
crate::json_ser::serialize_structure_crate_model_network_binding(
&mut object_360,
item_359,
)?;
object_360.finish();
}
}
array_358.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_submit_task_state_change_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SubmitTaskStateChangeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_361) = &input.cluster {
object.key("cluster").string(var_361.as_str());
}
if let Some(var_362) = &input.task {
object.key("task").string(var_362.as_str());
}
if let Some(var_363) = &input.status {
object.key("status").string(var_363.as_str());
}
if let Some(var_364) = &input.reason {
object.key("reason").string(var_364.as_str());
}
if let Some(var_365) = &input.containers {
let mut array_366 = object.key("containers").start_array();
for item_367 in var_365 {
{
#[allow(unused_mut)]
let mut object_368 = array_366.value().start_object();
crate::json_ser::serialize_structure_crate_model_container_state_change(
&mut object_368,
item_367,
)?;
object_368.finish();
}
}
array_366.finish();
}
if let Some(var_369) = &input.attachments {
let mut array_370 = object.key("attachments").start_array();
for item_371 in var_369 {
{
#[allow(unused_mut)]
let mut object_372 = array_370.value().start_object();
crate::json_ser::serialize_structure_crate_model_attachment_state_change(
&mut object_372,
item_371,
)?;
object_372.finish();
}
}
array_370.finish();
}
if let Some(var_373) = &input.managed_agents {
let mut array_374 = object.key("managedAgents").start_array();
for item_375 in var_373 {
{
#[allow(unused_mut)]
let mut object_376 = array_374.value().start_object();
crate::json_ser::serialize_structure_crate_model_managed_agent_state_change(
&mut object_376,
item_375,
)?;
object_376.finish();
}
}
array_374.finish();
}
if let Some(var_377) = &input.pull_started_at {
object
.key("pullStartedAt")
.date_time(var_377, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_378) = &input.pull_stopped_at {
object
.key("pullStoppedAt")
.date_time(var_378, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_379) = &input.execution_stopped_at {
object
.key("executionStoppedAt")
.date_time(var_379, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
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_380) = &input.resource_arn {
object.key("resourceArn").string(var_380.as_str());
}
if let Some(var_381) = &input.tags {
let mut array_382 = object.key("tags").start_array();
for item_383 in var_381 {
{
#[allow(unused_mut)]
let mut object_384 = array_382.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_384, item_383)?;
object_384.finish();
}
}
array_382.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_untag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UntagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_385) = &input.resource_arn {
object.key("resourceArn").string(var_385.as_str());
}
if let Some(var_386) = &input.tag_keys {
let mut array_387 = object.key("tagKeys").start_array();
for item_388 in var_386 {
{
array_387.value().string(item_388.as_str());
}
}
array_387.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_capacity_provider_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateCapacityProviderInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_389) = &input.name {
object.key("name").string(var_389.as_str());
}
if let Some(var_390) = &input.auto_scaling_group_provider {
#[allow(unused_mut)]
let mut object_391 = object.key("autoScalingGroupProvider").start_object();
crate::json_ser::serialize_structure_crate_model_auto_scaling_group_provider_update(
&mut object_391,
var_390,
)?;
object_391.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_cluster_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateClusterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_392) = &input.cluster {
object.key("cluster").string(var_392.as_str());
}
if let Some(var_393) = &input.settings {
let mut array_394 = object.key("settings").start_array();
for item_395 in var_393 {
{
#[allow(unused_mut)]
let mut object_396 = array_394.value().start_object();
crate::json_ser::serialize_structure_crate_model_cluster_setting(
&mut object_396,
item_395,
)?;
object_396.finish();
}
}
array_394.finish();
}
if let Some(var_397) = &input.configuration {
#[allow(unused_mut)]
let mut object_398 = object.key("configuration").start_object();
crate::json_ser::serialize_structure_crate_model_cluster_configuration(
&mut object_398,
var_397,
)?;
object_398.finish();
}
if let Some(var_399) = &input.service_connect_defaults {
#[allow(unused_mut)]
let mut object_400 = object.key("serviceConnectDefaults").start_object();
crate::json_ser::serialize_structure_crate_model_cluster_service_connect_defaults_request(
&mut object_400,
var_399,
)?;
object_400.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_cluster_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateClusterSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_401) = &input.cluster {
object.key("cluster").string(var_401.as_str());
}
if let Some(var_402) = &input.settings {
let mut array_403 = object.key("settings").start_array();
for item_404 in var_402 {
{
#[allow(unused_mut)]
let mut object_405 = array_403.value().start_object();
crate::json_ser::serialize_structure_crate_model_cluster_setting(
&mut object_405,
item_404,
)?;
object_405.finish();
}
}
array_403.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_container_agent_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateContainerAgentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_406) = &input.cluster {
object.key("cluster").string(var_406.as_str());
}
if let Some(var_407) = &input.container_instance {
object.key("containerInstance").string(var_407.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_container_instances_state_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateContainerInstancesStateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_408) = &input.cluster {
object.key("cluster").string(var_408.as_str());
}
if let Some(var_409) = &input.container_instances {
let mut array_410 = object.key("containerInstances").start_array();
for item_411 in var_409 {
{
array_410.value().string(item_411.as_str());
}
}
array_410.finish();
}
if let Some(var_412) = &input.status {
object.key("status").string(var_412.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_service_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateServiceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_413) = &input.cluster {
object.key("cluster").string(var_413.as_str());
}
if let Some(var_414) = &input.service {
object.key("service").string(var_414.as_str());
}
if let Some(var_415) = &input.desired_count {
object.key("desiredCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_415).into()),
);
}
if let Some(var_416) = &input.task_definition {
object.key("taskDefinition").string(var_416.as_str());
}
if let Some(var_417) = &input.capacity_provider_strategy {
let mut array_418 = object.key("capacityProviderStrategy").start_array();
for item_419 in var_417 {
{
#[allow(unused_mut)]
let mut object_420 = array_418.value().start_object();
crate::json_ser::serialize_structure_crate_model_capacity_provider_strategy_item(
&mut object_420,
item_419,
)?;
object_420.finish();
}
}
array_418.finish();
}
if let Some(var_421) = &input.deployment_configuration {
#[allow(unused_mut)]
let mut object_422 = object.key("deploymentConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_deployment_configuration(
&mut object_422,
var_421,
)?;
object_422.finish();
}
if let Some(var_423) = &input.network_configuration {
#[allow(unused_mut)]
let mut object_424 = object.key("networkConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_network_configuration(
&mut object_424,
var_423,
)?;
object_424.finish();
}
if let Some(var_425) = &input.placement_constraints {
let mut array_426 = object.key("placementConstraints").start_array();
for item_427 in var_425 {
{
#[allow(unused_mut)]
let mut object_428 = array_426.value().start_object();
crate::json_ser::serialize_structure_crate_model_placement_constraint(
&mut object_428,
item_427,
)?;
object_428.finish();
}
}
array_426.finish();
}
if let Some(var_429) = &input.placement_strategy {
let mut array_430 = object.key("placementStrategy").start_array();
for item_431 in var_429 {
{
#[allow(unused_mut)]
let mut object_432 = array_430.value().start_object();
crate::json_ser::serialize_structure_crate_model_placement_strategy(
&mut object_432,
item_431,
)?;
object_432.finish();
}
}
array_430.finish();
}
if let Some(var_433) = &input.platform_version {
object.key("platformVersion").string(var_433.as_str());
}
if input.force_new_deployment {
object
.key("forceNewDeployment")
.boolean(input.force_new_deployment);
}
if let Some(var_434) = &input.health_check_grace_period_seconds {
object.key("healthCheckGracePeriodSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_434).into()),
);
}
if let Some(var_435) = &input.enable_execute_command {
object.key("enableExecuteCommand").boolean(*var_435);
}
if let Some(var_436) = &input.enable_ecs_managed_tags {
object.key("enableECSManagedTags").boolean(*var_436);
}
if let Some(var_437) = &input.load_balancers {
let mut array_438 = object.key("loadBalancers").start_array();
for item_439 in var_437 {
{
#[allow(unused_mut)]
let mut object_440 = array_438.value().start_object();
crate::json_ser::serialize_structure_crate_model_load_balancer(
&mut object_440,
item_439,
)?;
object_440.finish();
}
}
array_438.finish();
}
if let Some(var_441) = &input.propagate_tags {
object.key("propagateTags").string(var_441.as_str());
}
if let Some(var_442) = &input.service_registries {
let mut array_443 = object.key("serviceRegistries").start_array();
for item_444 in var_442 {
{
#[allow(unused_mut)]
let mut object_445 = array_443.value().start_object();
crate::json_ser::serialize_structure_crate_model_service_registry(
&mut object_445,
item_444,
)?;
object_445.finish();
}
}
array_443.finish();
}
if let Some(var_446) = &input.service_connect_configuration {
#[allow(unused_mut)]
let mut object_447 = object.key("serviceConnectConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_service_connect_configuration(
&mut object_447,
var_446,
)?;
object_447.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_service_primary_task_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateServicePrimaryTaskSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_448) = &input.cluster {
object.key("cluster").string(var_448.as_str());
}
if let Some(var_449) = &input.service {
object.key("service").string(var_449.as_str());
}
if let Some(var_450) = &input.primary_task_set {
object.key("primaryTaskSet").string(var_450.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_task_protection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateTaskProtectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_451) = &input.cluster {
object.key("cluster").string(var_451.as_str());
}
if let Some(var_452) = &input.tasks {
let mut array_453 = object.key("tasks").start_array();
for item_454 in var_452 {
{
array_453.value().string(item_454.as_str());
}
}
array_453.finish();
}
{
object
.key("protectionEnabled")
.boolean(input.protection_enabled);
}
if let Some(var_455) = &input.expires_in_minutes {
object.key("expiresInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_455).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_task_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateTaskSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_456) = &input.cluster {
object.key("cluster").string(var_456.as_str());
}
if let Some(var_457) = &input.service {
object.key("service").string(var_457.as_str());
}
if let Some(var_458) = &input.task_set {
object.key("taskSet").string(var_458.as_str());
}
if let Some(var_459) = &input.scale {
#[allow(unused_mut)]
let mut object_460 = object.key("scale").start_object();
crate::json_ser::serialize_structure_crate_model_scale(&mut object_460, var_459)?;
object_460.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_scaling_group_provider(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoScalingGroupProvider,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_461) = &input.auto_scaling_group_arn {
object.key("autoScalingGroupArn").string(var_461.as_str());
}
if let Some(var_462) = &input.managed_scaling {
#[allow(unused_mut)]
let mut object_463 = object.key("managedScaling").start_object();
crate::json_ser::serialize_structure_crate_model_managed_scaling(&mut object_463, var_462)?;
object_463.finish();
}
if let Some(var_464) = &input.managed_termination_protection {
object
.key("managedTerminationProtection")
.string(var_464.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_465) = &input.key {
object.key("key").string(var_465.as_str());
}
if let Some(var_466) = &input.value {
object.key("value").string(var_466.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_cluster_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ClusterSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_467) = &input.name {
object.key("name").string(var_467.as_str());
}
if let Some(var_468) = &input.value {
object.key("value").string(var_468.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_cluster_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ClusterConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_469) = &input.execute_command_configuration {
#[allow(unused_mut)]
let mut object_470 = object.key("executeCommandConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_execute_command_configuration(
&mut object_470,
var_469,
)?;
object_470.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_capacity_provider_strategy_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CapacityProviderStrategyItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_471) = &input.capacity_provider {
object.key("capacityProvider").string(var_471.as_str());
}
if input.weight != 0 {
object.key("weight").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.weight).into()),
);
}
if input.base != 0 {
object.key("base").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.base).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_cluster_service_connect_defaults_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ClusterServiceConnectDefaultsRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_472) = &input.namespace {
object.key("namespace").string(var_472.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_load_balancer(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoadBalancer,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_473) = &input.target_group_arn {
object.key("targetGroupArn").string(var_473.as_str());
}
if let Some(var_474) = &input.load_balancer_name {
object.key("loadBalancerName").string(var_474.as_str());
}
if let Some(var_475) = &input.container_name {
object.key("containerName").string(var_475.as_str());
}
if let Some(var_476) = &input.container_port {
object.key("containerPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_476).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_service_registry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServiceRegistry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_477) = &input.registry_arn {
object.key("registryArn").string(var_477.as_str());
}
if let Some(var_478) = &input.port {
object.key("port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_478).into()),
);
}
if let Some(var_479) = &input.container_name {
object.key("containerName").string(var_479.as_str());
}
if let Some(var_480) = &input.container_port {
object.key("containerPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_480).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_deployment_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeploymentConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_481) = &input.deployment_circuit_breaker {
#[allow(unused_mut)]
let mut object_482 = object.key("deploymentCircuitBreaker").start_object();
crate::json_ser::serialize_structure_crate_model_deployment_circuit_breaker(
&mut object_482,
var_481,
)?;
object_482.finish();
}
if let Some(var_483) = &input.maximum_percent {
object.key("maximumPercent").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_483).into()),
);
}
if let Some(var_484) = &input.minimum_healthy_percent {
object.key("minimumHealthyPercent").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_484).into()),
);
}
if let Some(var_485) = &input.alarms {
#[allow(unused_mut)]
let mut object_486 = object.key("alarms").start_object();
crate::json_ser::serialize_structure_crate_model_deployment_alarms(
&mut object_486,
var_485,
)?;
object_486.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_placement_constraint(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PlacementConstraint,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_487) = &input.r#type {
object.key("type").string(var_487.as_str());
}
if let Some(var_488) = &input.expression {
object.key("expression").string(var_488.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_placement_strategy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PlacementStrategy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_489) = &input.r#type {
object.key("type").string(var_489.as_str());
}
if let Some(var_490) = &input.field {
object.key("field").string(var_490.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_network_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NetworkConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_491) = &input.awsvpc_configuration {
#[allow(unused_mut)]
let mut object_492 = object.key("awsvpcConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_aws_vpc_configuration(
&mut object_492,
var_491,
)?;
object_492.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_deployment_controller(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeploymentController,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_493) = &input.r#type {
object.key("type").string(var_493.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_service_connect_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServiceConnectConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("enabled").boolean(input.enabled);
}
if let Some(var_494) = &input.namespace {
object.key("namespace").string(var_494.as_str());
}
if let Some(var_495) = &input.services {
let mut array_496 = object.key("services").start_array();
for item_497 in var_495 {
{
#[allow(unused_mut)]
let mut object_498 = array_496.value().start_object();
crate::json_ser::serialize_structure_crate_model_service_connect_service(
&mut object_498,
item_497,
)?;
object_498.finish();
}
}
array_496.finish();
}
if let Some(var_499) = &input.log_configuration {
#[allow(unused_mut)]
let mut object_500 = object.key("logConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_log_configuration(
&mut object_500,
var_499,
)?;
object_500.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_scale(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Scale,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.value != 0.0 {
object.key("value").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.value).into()),
);
}
if let Some(var_501) = &input.unit {
object.key("unit").string(var_501.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_attribute(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Attribute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_502) = &input.name {
object.key("name").string(var_502.as_str());
}
if let Some(var_503) = &input.value {
object.key("value").string(var_503.as_str());
}
if let Some(var_504) = &input.target_type {
object.key("targetType").string(var_504.as_str());
}
if let Some(var_505) = &input.target_id {
object.key("targetId").string(var_505.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_resource(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Resource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_506) = &input.name {
object.key("name").string(var_506.as_str());
}
if let Some(var_507) = &input.r#type {
object.key("type").string(var_507.as_str());
}
if input.double_value != 0.0 {
object.key("doubleValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.double_value).into()),
);
}
if input.long_value != 0 {
object.key("longValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.long_value).into()),
);
}
if input.integer_value != 0 {
object.key("integerValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.integer_value).into()),
);
}
if let Some(var_508) = &input.string_set_value {
let mut array_509 = object.key("stringSetValue").start_array();
for item_510 in var_508 {
{
array_509.value().string(item_510.as_str());
}
}
array_509.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_version_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VersionInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_511) = &input.agent_version {
object.key("agentVersion").string(var_511.as_str());
}
if let Some(var_512) = &input.agent_hash {
object.key("agentHash").string(var_512.as_str());
}
if let Some(var_513) = &input.docker_version {
object.key("dockerVersion").string(var_513.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_platform_device(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PlatformDevice,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_514) = &input.id {
object.key("id").string(var_514.as_str());
}
if let Some(var_515) = &input.r#type {
object.key("type").string(var_515.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_container_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ContainerDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_516) = &input.name {
object.key("name").string(var_516.as_str());
}
if let Some(var_517) = &input.image {
object.key("image").string(var_517.as_str());
}
if let Some(var_518) = &input.repository_credentials {
#[allow(unused_mut)]
let mut object_519 = object.key("repositoryCredentials").start_object();
crate::json_ser::serialize_structure_crate_model_repository_credentials(
&mut object_519,
var_518,
)?;
object_519.finish();
}
if input.cpu != 0 {
object.key("cpu").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.cpu).into()),
);
}
if let Some(var_520) = &input.memory {
object.key("memory").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_520).into()),
);
}
if let Some(var_521) = &input.memory_reservation {
object.key("memoryReservation").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_521).into()),
);
}
if let Some(var_522) = &input.links {
let mut array_523 = object.key("links").start_array();
for item_524 in var_522 {
{
array_523.value().string(item_524.as_str());
}
}
array_523.finish();
}
if let Some(var_525) = &input.port_mappings {
let mut array_526 = object.key("portMappings").start_array();
for item_527 in var_525 {
{
#[allow(unused_mut)]
let mut object_528 = array_526.value().start_object();
crate::json_ser::serialize_structure_crate_model_port_mapping(
&mut object_528,
item_527,
)?;
object_528.finish();
}
}
array_526.finish();
}
if let Some(var_529) = &input.essential {
object.key("essential").boolean(*var_529);
}
if let Some(var_530) = &input.entry_point {
let mut array_531 = object.key("entryPoint").start_array();
for item_532 in var_530 {
{
array_531.value().string(item_532.as_str());
}
}
array_531.finish();
}
if let Some(var_533) = &input.command {
let mut array_534 = object.key("command").start_array();
for item_535 in var_533 {
{
array_534.value().string(item_535.as_str());
}
}
array_534.finish();
}
if let Some(var_536) = &input.environment {
let mut array_537 = object.key("environment").start_array();
for item_538 in var_536 {
{
#[allow(unused_mut)]
let mut object_539 = array_537.value().start_object();
crate::json_ser::serialize_structure_crate_model_key_value_pair(
&mut object_539,
item_538,
)?;
object_539.finish();
}
}
array_537.finish();
}
if let Some(var_540) = &input.environment_files {
let mut array_541 = object.key("environmentFiles").start_array();
for item_542 in var_540 {
{
#[allow(unused_mut)]
let mut object_543 = array_541.value().start_object();
crate::json_ser::serialize_structure_crate_model_environment_file(
&mut object_543,
item_542,
)?;
object_543.finish();
}
}
array_541.finish();
}
if let Some(var_544) = &input.mount_points {
let mut array_545 = object.key("mountPoints").start_array();
for item_546 in var_544 {
{
#[allow(unused_mut)]
let mut object_547 = array_545.value().start_object();
crate::json_ser::serialize_structure_crate_model_mount_point(
&mut object_547,
item_546,
)?;
object_547.finish();
}
}
array_545.finish();
}
if let Some(var_548) = &input.volumes_from {
let mut array_549 = object.key("volumesFrom").start_array();
for item_550 in var_548 {
{
#[allow(unused_mut)]
let mut object_551 = array_549.value().start_object();
crate::json_ser::serialize_structure_crate_model_volume_from(
&mut object_551,
item_550,
)?;
object_551.finish();
}
}
array_549.finish();
}
if let Some(var_552) = &input.linux_parameters {
#[allow(unused_mut)]
let mut object_553 = object.key("linuxParameters").start_object();
crate::json_ser::serialize_structure_crate_model_linux_parameters(
&mut object_553,
var_552,
)?;
object_553.finish();
}
if let Some(var_554) = &input.secrets {
let mut array_555 = object.key("secrets").start_array();
for item_556 in var_554 {
{
#[allow(unused_mut)]
let mut object_557 = array_555.value().start_object();
crate::json_ser::serialize_structure_crate_model_secret(&mut object_557, item_556)?;
object_557.finish();
}
}
array_555.finish();
}
if let Some(var_558) = &input.depends_on {
let mut array_559 = object.key("dependsOn").start_array();
for item_560 in var_558 {
{
#[allow(unused_mut)]
let mut object_561 = array_559.value().start_object();
crate::json_ser::serialize_structure_crate_model_container_dependency(
&mut object_561,
item_560,
)?;
object_561.finish();
}
}
array_559.finish();
}
if let Some(var_562) = &input.start_timeout {
object.key("startTimeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_562).into()),
);
}
if let Some(var_563) = &input.stop_timeout {
object.key("stopTimeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_563).into()),
);
}
if let Some(var_564) = &input.hostname {
object.key("hostname").string(var_564.as_str());
}
if let Some(var_565) = &input.user {
object.key("user").string(var_565.as_str());
}
if let Some(var_566) = &input.working_directory {
object.key("workingDirectory").string(var_566.as_str());
}
if let Some(var_567) = &input.disable_networking {
object.key("disableNetworking").boolean(*var_567);
}
if let Some(var_568) = &input.privileged {
object.key("privileged").boolean(*var_568);
}
if let Some(var_569) = &input.readonly_root_filesystem {
object.key("readonlyRootFilesystem").boolean(*var_569);
}
if let Some(var_570) = &input.dns_servers {
let mut array_571 = object.key("dnsServers").start_array();
for item_572 in var_570 {
{
array_571.value().string(item_572.as_str());
}
}
array_571.finish();
}
if let Some(var_573) = &input.dns_search_domains {
let mut array_574 = object.key("dnsSearchDomains").start_array();
for item_575 in var_573 {
{
array_574.value().string(item_575.as_str());
}
}
array_574.finish();
}
if let Some(var_576) = &input.extra_hosts {
let mut array_577 = object.key("extraHosts").start_array();
for item_578 in var_576 {
{
#[allow(unused_mut)]
let mut object_579 = array_577.value().start_object();
crate::json_ser::serialize_structure_crate_model_host_entry(
&mut object_579,
item_578,
)?;
object_579.finish();
}
}
array_577.finish();
}
if let Some(var_580) = &input.docker_security_options {
let mut array_581 = object.key("dockerSecurityOptions").start_array();
for item_582 in var_580 {
{
array_581.value().string(item_582.as_str());
}
}
array_581.finish();
}
if let Some(var_583) = &input.interactive {
object.key("interactive").boolean(*var_583);
}
if let Some(var_584) = &input.pseudo_terminal {
object.key("pseudoTerminal").boolean(*var_584);
}
if let Some(var_585) = &input.docker_labels {
#[allow(unused_mut)]
let mut object_586 = object.key("dockerLabels").start_object();
for (key_587, value_588) in var_585 {
{
object_586.key(key_587.as_str()).string(value_588.as_str());
}
}
object_586.finish();
}
if let Some(var_589) = &input.ulimits {
let mut array_590 = object.key("ulimits").start_array();
for item_591 in var_589 {
{
#[allow(unused_mut)]
let mut object_592 = array_590.value().start_object();
crate::json_ser::serialize_structure_crate_model_ulimit(&mut object_592, item_591)?;
object_592.finish();
}
}
array_590.finish();
}
if let Some(var_593) = &input.log_configuration {
#[allow(unused_mut)]
let mut object_594 = object.key("logConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_log_configuration(
&mut object_594,
var_593,
)?;
object_594.finish();
}
if let Some(var_595) = &input.health_check {
#[allow(unused_mut)]
let mut object_596 = object.key("healthCheck").start_object();
crate::json_ser::serialize_structure_crate_model_health_check(&mut object_596, var_595)?;
object_596.finish();
}
if let Some(var_597) = &input.system_controls {
let mut array_598 = object.key("systemControls").start_array();
for item_599 in var_597 {
{
#[allow(unused_mut)]
let mut object_600 = array_598.value().start_object();
crate::json_ser::serialize_structure_crate_model_system_control(
&mut object_600,
item_599,
)?;
object_600.finish();
}
}
array_598.finish();
}
if let Some(var_601) = &input.resource_requirements {
let mut array_602 = object.key("resourceRequirements").start_array();
for item_603 in var_601 {
{
#[allow(unused_mut)]
let mut object_604 = array_602.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_requirement(
&mut object_604,
item_603,
)?;
object_604.finish();
}
}
array_602.finish();
}
if let Some(var_605) = &input.firelens_configuration {
#[allow(unused_mut)]
let mut object_606 = object.key("firelensConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_firelens_configuration(
&mut object_606,
var_605,
)?;
object_606.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_volume(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Volume,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_607) = &input.name {
object.key("name").string(var_607.as_str());
}
if let Some(var_608) = &input.host {
#[allow(unused_mut)]
let mut object_609 = object.key("host").start_object();
crate::json_ser::serialize_structure_crate_model_host_volume_properties(
&mut object_609,
var_608,
)?;
object_609.finish();
}
if let Some(var_610) = &input.docker_volume_configuration {
#[allow(unused_mut)]
let mut object_611 = object.key("dockerVolumeConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_docker_volume_configuration(
&mut object_611,
var_610,
)?;
object_611.finish();
}
if let Some(var_612) = &input.efs_volume_configuration {
#[allow(unused_mut)]
let mut object_613 = object.key("efsVolumeConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_efs_volume_configuration(
&mut object_613,
var_612,
)?;
object_613.finish();
}
if let Some(var_614) = &input.fsx_windows_file_server_volume_configuration {
#[allow(unused_mut)]
let mut object_615 = object
.key("fsxWindowsFileServerVolumeConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_f_sx_windows_file_server_volume_configuration(&mut object_615, var_614)?;
object_615.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_task_definition_placement_constraint(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TaskDefinitionPlacementConstraint,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_616) = &input.r#type {
object.key("type").string(var_616.as_str());
}
if let Some(var_617) = &input.expression {
object.key("expression").string(var_617.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_proxy_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProxyConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_618) = &input.r#type {
object.key("type").string(var_618.as_str());
}
if let Some(var_619) = &input.container_name {
object.key("containerName").string(var_619.as_str());
}
if let Some(var_620) = &input.properties {
let mut array_621 = object.key("properties").start_array();
for item_622 in var_620 {
{
#[allow(unused_mut)]
let mut object_623 = array_621.value().start_object();
crate::json_ser::serialize_structure_crate_model_key_value_pair(
&mut object_623,
item_622,
)?;
object_623.finish();
}
}
array_621.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_inference_accelerator(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InferenceAccelerator,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_624) = &input.device_name {
object.key("deviceName").string(var_624.as_str());
}
if let Some(var_625) = &input.device_type {
object.key("deviceType").string(var_625.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ephemeral_storage(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EphemeralStorage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("sizeInGiB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.size_in_gi_b).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_runtime_platform(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuntimePlatform,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_626) = &input.cpu_architecture {
object.key("cpuArchitecture").string(var_626.as_str());
}
if let Some(var_627) = &input.operating_system_family {
object.key("operatingSystemFamily").string(var_627.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_task_override(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TaskOverride,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_628) = &input.container_overrides {
let mut array_629 = object.key("containerOverrides").start_array();
for item_630 in var_628 {
{
#[allow(unused_mut)]
let mut object_631 = array_629.value().start_object();
crate::json_ser::serialize_structure_crate_model_container_override(
&mut object_631,
item_630,
)?;
object_631.finish();
}
}
array_629.finish();
}
if let Some(var_632) = &input.cpu {
object.key("cpu").string(var_632.as_str());
}
if let Some(var_633) = &input.inference_accelerator_overrides {
let mut array_634 = object.key("inferenceAcceleratorOverrides").start_array();
for item_635 in var_633 {
{
#[allow(unused_mut)]
let mut object_636 = array_634.value().start_object();
crate::json_ser::serialize_structure_crate_model_inference_accelerator_override(
&mut object_636,
item_635,
)?;
object_636.finish();
}
}
array_634.finish();
}
if let Some(var_637) = &input.execution_role_arn {
object.key("executionRoleArn").string(var_637.as_str());
}
if let Some(var_638) = &input.memory {
object.key("memory").string(var_638.as_str());
}
if let Some(var_639) = &input.task_role_arn {
object.key("taskRoleArn").string(var_639.as_str());
}
if let Some(var_640) = &input.ephemeral_storage {
#[allow(unused_mut)]
let mut object_641 = object.key("ephemeralStorage").start_object();
crate::json_ser::serialize_structure_crate_model_ephemeral_storage(
&mut object_641,
var_640,
)?;
object_641.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_attachment_state_change(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AttachmentStateChange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_642) = &input.attachment_arn {
object.key("attachmentArn").string(var_642.as_str());
}
if let Some(var_643) = &input.status {
object.key("status").string(var_643.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_network_binding(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NetworkBinding,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_644) = &input.bind_ip {
object.key("bindIP").string(var_644.as_str());
}
if let Some(var_645) = &input.container_port {
object.key("containerPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_645).into()),
);
}
if let Some(var_646) = &input.host_port {
object.key("hostPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_646).into()),
);
}
if let Some(var_647) = &input.protocol {
object.key("protocol").string(var_647.as_str());
}
if let Some(var_648) = &input.container_port_range {
object.key("containerPortRange").string(var_648.as_str());
}
if let Some(var_649) = &input.host_port_range {
object.key("hostPortRange").string(var_649.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_container_state_change(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ContainerStateChange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_650) = &input.container_name {
object.key("containerName").string(var_650.as_str());
}
if let Some(var_651) = &input.image_digest {
object.key("imageDigest").string(var_651.as_str());
}
if let Some(var_652) = &input.runtime_id {
object.key("runtimeId").string(var_652.as_str());
}
if let Some(var_653) = &input.exit_code {
object.key("exitCode").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_653).into()),
);
}
if let Some(var_654) = &input.network_bindings {
let mut array_655 = object.key("networkBindings").start_array();
for item_656 in var_654 {
{
#[allow(unused_mut)]
let mut object_657 = array_655.value().start_object();
crate::json_ser::serialize_structure_crate_model_network_binding(
&mut object_657,
item_656,
)?;
object_657.finish();
}
}
array_655.finish();
}
if let Some(var_658) = &input.reason {
object.key("reason").string(var_658.as_str());
}
if let Some(var_659) = &input.status {
object.key("status").string(var_659.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_managed_agent_state_change(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ManagedAgentStateChange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_660) = &input.container_name {
object.key("containerName").string(var_660.as_str());
}
if let Some(var_661) = &input.managed_agent_name {
object.key("managedAgentName").string(var_661.as_str());
}
if let Some(var_662) = &input.status {
object.key("status").string(var_662.as_str());
}
if let Some(var_663) = &input.reason {
object.key("reason").string(var_663.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_scaling_group_provider_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoScalingGroupProviderUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_664) = &input.managed_scaling {
#[allow(unused_mut)]
let mut object_665 = object.key("managedScaling").start_object();
crate::json_ser::serialize_structure_crate_model_managed_scaling(&mut object_665, var_664)?;
object_665.finish();
}
if let Some(var_666) = &input.managed_termination_protection {
object
.key("managedTerminationProtection")
.string(var_666.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_managed_scaling(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ManagedScaling,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_667) = &input.status {
object.key("status").string(var_667.as_str());
}
if let Some(var_668) = &input.target_capacity {
object.key("targetCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_668).into()),
);
}
if let Some(var_669) = &input.minimum_scaling_step_size {
object.key("minimumScalingStepSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_669).into()),
);
}
if let Some(var_670) = &input.maximum_scaling_step_size {
object.key("maximumScalingStepSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_670).into()),
);
}
if let Some(var_671) = &input.instance_warmup_period {
object.key("instanceWarmupPeriod").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_671).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_execute_command_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExecuteCommandConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_672) = &input.kms_key_id {
object.key("kmsKeyId").string(var_672.as_str());
}
if let Some(var_673) = &input.logging {
object.key("logging").string(var_673.as_str());
}
if let Some(var_674) = &input.log_configuration {
#[allow(unused_mut)]
let mut object_675 = object.key("logConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_execute_command_log_configuration(
&mut object_675,
var_674,
)?;
object_675.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_deployment_circuit_breaker(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeploymentCircuitBreaker,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("enable").boolean(input.enable);
}
{
object.key("rollback").boolean(input.rollback);
}
Ok(())
}
pub fn serialize_structure_crate_model_deployment_alarms(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeploymentAlarms,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_676) = &input.alarm_names {
let mut array_677 = object.key("alarmNames").start_array();
for item_678 in var_676 {
{
array_677.value().string(item_678.as_str());
}
}
array_677.finish();
}
{
object.key("enable").boolean(input.enable);
}
{
object.key("rollback").boolean(input.rollback);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_vpc_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsVpcConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_679) = &input.subnets {
let mut array_680 = object.key("subnets").start_array();
for item_681 in var_679 {
{
array_680.value().string(item_681.as_str());
}
}
array_680.finish();
}
if let Some(var_682) = &input.security_groups {
let mut array_683 = object.key("securityGroups").start_array();
for item_684 in var_682 {
{
array_683.value().string(item_684.as_str());
}
}
array_683.finish();
}
if let Some(var_685) = &input.assign_public_ip {
object.key("assignPublicIp").string(var_685.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_service_connect_service(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServiceConnectService,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_686) = &input.port_name {
object.key("portName").string(var_686.as_str());
}
if let Some(var_687) = &input.discovery_name {
object.key("discoveryName").string(var_687.as_str());
}
if let Some(var_688) = &input.client_aliases {
let mut array_689 = object.key("clientAliases").start_array();
for item_690 in var_688 {
{
#[allow(unused_mut)]
let mut object_691 = array_689.value().start_object();
crate::json_ser::serialize_structure_crate_model_service_connect_client_alias(
&mut object_691,
item_690,
)?;
object_691.finish();
}
}
array_689.finish();
}
if let Some(var_692) = &input.ingress_port_override {
object.key("ingressPortOverride").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_692).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_log_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LogConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_693) = &input.log_driver {
object.key("logDriver").string(var_693.as_str());
}
if let Some(var_694) = &input.options {
#[allow(unused_mut)]
let mut object_695 = object.key("options").start_object();
for (key_696, value_697) in var_694 {
{
object_695.key(key_696.as_str()).string(value_697.as_str());
}
}
object_695.finish();
}
if let Some(var_698) = &input.secret_options {
let mut array_699 = object.key("secretOptions").start_array();
for item_700 in var_698 {
{
#[allow(unused_mut)]
let mut object_701 = array_699.value().start_object();
crate::json_ser::serialize_structure_crate_model_secret(&mut object_701, item_700)?;
object_701.finish();
}
}
array_699.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_repository_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RepositoryCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_702) = &input.credentials_parameter {
object.key("credentialsParameter").string(var_702.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_port_mapping(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PortMapping,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_703) = &input.container_port {
object.key("containerPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_703).into()),
);
}
if let Some(var_704) = &input.host_port {
object.key("hostPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_704).into()),
);
}
if let Some(var_705) = &input.protocol {
object.key("protocol").string(var_705.as_str());
}
if let Some(var_706) = &input.name {
object.key("name").string(var_706.as_str());
}
if let Some(var_707) = &input.app_protocol {
object.key("appProtocol").string(var_707.as_str());
}
if let Some(var_708) = &input.container_port_range {
object.key("containerPortRange").string(var_708.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_key_value_pair(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KeyValuePair,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_709) = &input.name {
object.key("name").string(var_709.as_str());
}
if let Some(var_710) = &input.value {
object.key("value").string(var_710.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_environment_file(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EnvironmentFile,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_711) = &input.value {
object.key("value").string(var_711.as_str());
}
if let Some(var_712) = &input.r#type {
object.key("type").string(var_712.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_mount_point(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MountPoint,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_713) = &input.source_volume {
object.key("sourceVolume").string(var_713.as_str());
}
if let Some(var_714) = &input.container_path {
object.key("containerPath").string(var_714.as_str());
}
if let Some(var_715) = &input.read_only {
object.key("readOnly").boolean(*var_715);
}
Ok(())
}
pub fn serialize_structure_crate_model_volume_from(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VolumeFrom,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_716) = &input.source_container {
object.key("sourceContainer").string(var_716.as_str());
}
if let Some(var_717) = &input.read_only {
object.key("readOnly").boolean(*var_717);
}
Ok(())
}
pub fn serialize_structure_crate_model_linux_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LinuxParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_718) = &input.capabilities {
#[allow(unused_mut)]
let mut object_719 = object.key("capabilities").start_object();
crate::json_ser::serialize_structure_crate_model_kernel_capabilities(
&mut object_719,
var_718,
)?;
object_719.finish();
}
if let Some(var_720) = &input.devices {
let mut array_721 = object.key("devices").start_array();
for item_722 in var_720 {
{
#[allow(unused_mut)]
let mut object_723 = array_721.value().start_object();
crate::json_ser::serialize_structure_crate_model_device(&mut object_723, item_722)?;
object_723.finish();
}
}
array_721.finish();
}
if let Some(var_724) = &input.init_process_enabled {
object.key("initProcessEnabled").boolean(*var_724);
}
if let Some(var_725) = &input.shared_memory_size {
object.key("sharedMemorySize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_725).into()),
);
}
if let Some(var_726) = &input.tmpfs {
let mut array_727 = object.key("tmpfs").start_array();
for item_728 in var_726 {
{
#[allow(unused_mut)]
let mut object_729 = array_727.value().start_object();
crate::json_ser::serialize_structure_crate_model_tmpfs(&mut object_729, item_728)?;
object_729.finish();
}
}
array_727.finish();
}
if let Some(var_730) = &input.max_swap {
object.key("maxSwap").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_730).into()),
);
}
if let Some(var_731) = &input.swappiness {
object.key("swappiness").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_731).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_secret(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Secret,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_732) = &input.name {
object.key("name").string(var_732.as_str());
}
if let Some(var_733) = &input.value_from {
object.key("valueFrom").string(var_733.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_container_dependency(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ContainerDependency,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_734) = &input.container_name {
object.key("containerName").string(var_734.as_str());
}
if let Some(var_735) = &input.condition {
object.key("condition").string(var_735.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_host_entry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HostEntry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_736) = &input.hostname {
object.key("hostname").string(var_736.as_str());
}
if let Some(var_737) = &input.ip_address {
object.key("ipAddress").string(var_737.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ulimit(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Ulimit,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_738) = &input.name {
object.key("name").string(var_738.as_str());
}
{
object.key("softLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.soft_limit).into()),
);
}
{
object.key("hardLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.hard_limit).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_health_check(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HealthCheck,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_739) = &input.command {
let mut array_740 = object.key("command").start_array();
for item_741 in var_739 {
{
array_740.value().string(item_741.as_str());
}
}
array_740.finish();
}
if let Some(var_742) = &input.interval {
object.key("interval").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_742).into()),
);
}
if let Some(var_743) = &input.timeout {
object.key("timeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_743).into()),
);
}
if let Some(var_744) = &input.retries {
object.key("retries").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_744).into()),
);
}
if let Some(var_745) = &input.start_period {
object.key("startPeriod").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_745).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_system_control(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SystemControl,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_746) = &input.namespace {
object.key("namespace").string(var_746.as_str());
}
if let Some(var_747) = &input.value {
object.key("value").string(var_747.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_requirement(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourceRequirement,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_748) = &input.value {
object.key("value").string(var_748.as_str());
}
if let Some(var_749) = &input.r#type {
object.key("type").string(var_749.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_firelens_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FirelensConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_750) = &input.r#type {
object.key("type").string(var_750.as_str());
}
if let Some(var_751) = &input.options {
#[allow(unused_mut)]
let mut object_752 = object.key("options").start_object();
for (key_753, value_754) in var_751 {
{
object_752.key(key_753.as_str()).string(value_754.as_str());
}
}
object_752.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_host_volume_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HostVolumeProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_755) = &input.source_path {
object.key("sourcePath").string(var_755.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_docker_volume_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DockerVolumeConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_756) = &input.scope {
object.key("scope").string(var_756.as_str());
}
if let Some(var_757) = &input.autoprovision {
object.key("autoprovision").boolean(*var_757);
}
if let Some(var_758) = &input.driver {
object.key("driver").string(var_758.as_str());
}
if let Some(var_759) = &input.driver_opts {
#[allow(unused_mut)]
let mut object_760 = object.key("driverOpts").start_object();
for (key_761, value_762) in var_759 {
{
object_760.key(key_761.as_str()).string(value_762.as_str());
}
}
object_760.finish();
}
if let Some(var_763) = &input.labels {
#[allow(unused_mut)]
let mut object_764 = object.key("labels").start_object();
for (key_765, value_766) in var_763 {
{
object_764.key(key_765.as_str()).string(value_766.as_str());
}
}
object_764.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_efs_volume_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EfsVolumeConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_767) = &input.file_system_id {
object.key("fileSystemId").string(var_767.as_str());
}
if let Some(var_768) = &input.root_directory {
object.key("rootDirectory").string(var_768.as_str());
}
if let Some(var_769) = &input.transit_encryption {
object.key("transitEncryption").string(var_769.as_str());
}
if let Some(var_770) = &input.transit_encryption_port {
object.key("transitEncryptionPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_770).into()),
);
}
if let Some(var_771) = &input.authorization_config {
#[allow(unused_mut)]
let mut object_772 = object.key("authorizationConfig").start_object();
crate::json_ser::serialize_structure_crate_model_efs_authorization_config(
&mut object_772,
var_771,
)?;
object_772.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_f_sx_windows_file_server_volume_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FSxWindowsFileServerVolumeConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_773) = &input.file_system_id {
object.key("fileSystemId").string(var_773.as_str());
}
if let Some(var_774) = &input.root_directory {
object.key("rootDirectory").string(var_774.as_str());
}
if let Some(var_775) = &input.authorization_config {
#[allow(unused_mut)]
let mut object_776 = object.key("authorizationConfig").start_object();
crate::json_ser::serialize_structure_crate_model_f_sx_windows_file_server_authorization_config(&mut object_776, var_775)?;
object_776.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_container_override(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ContainerOverride,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_777) = &input.name {
object.key("name").string(var_777.as_str());
}
if let Some(var_778) = &input.command {
let mut array_779 = object.key("command").start_array();
for item_780 in var_778 {
{
array_779.value().string(item_780.as_str());
}
}
array_779.finish();
}
if let Some(var_781) = &input.environment {
let mut array_782 = object.key("environment").start_array();
for item_783 in var_781 {
{
#[allow(unused_mut)]
let mut object_784 = array_782.value().start_object();
crate::json_ser::serialize_structure_crate_model_key_value_pair(
&mut object_784,
item_783,
)?;
object_784.finish();
}
}
array_782.finish();
}
if let Some(var_785) = &input.environment_files {
let mut array_786 = object.key("environmentFiles").start_array();
for item_787 in var_785 {
{
#[allow(unused_mut)]
let mut object_788 = array_786.value().start_object();
crate::json_ser::serialize_structure_crate_model_environment_file(
&mut object_788,
item_787,
)?;
object_788.finish();
}
}
array_786.finish();
}
if let Some(var_789) = &input.cpu {
object.key("cpu").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_789).into()),
);
}
if let Some(var_790) = &input.memory {
object.key("memory").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_790).into()),
);
}
if let Some(var_791) = &input.memory_reservation {
object.key("memoryReservation").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_791).into()),
);
}
if let Some(var_792) = &input.resource_requirements {
let mut array_793 = object.key("resourceRequirements").start_array();
for item_794 in var_792 {
{
#[allow(unused_mut)]
let mut object_795 = array_793.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_requirement(
&mut object_795,
item_794,
)?;
object_795.finish();
}
}
array_793.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_inference_accelerator_override(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InferenceAcceleratorOverride,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_796) = &input.device_name {
object.key("deviceName").string(var_796.as_str());
}
if let Some(var_797) = &input.device_type {
object.key("deviceType").string(var_797.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_execute_command_log_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExecuteCommandLogConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_798) = &input.cloud_watch_log_group_name {
object
.key("cloudWatchLogGroupName")
.string(var_798.as_str());
}
if input.cloud_watch_encryption_enabled {
object
.key("cloudWatchEncryptionEnabled")
.boolean(input.cloud_watch_encryption_enabled);
}
if let Some(var_799) = &input.s3_bucket_name {
object.key("s3BucketName").string(var_799.as_str());
}
if input.s3_encryption_enabled {
object
.key("s3EncryptionEnabled")
.boolean(input.s3_encryption_enabled);
}
if let Some(var_800) = &input.s3_key_prefix {
object.key("s3KeyPrefix").string(var_800.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_service_connect_client_alias(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServiceConnectClientAlias,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_801) = &input.port {
object.key("port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_801).into()),
);
}
if let Some(var_802) = &input.dns_name {
object.key("dnsName").string(var_802.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_kernel_capabilities(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KernelCapabilities,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_803) = &input.add {
let mut array_804 = object.key("add").start_array();
for item_805 in var_803 {
{
array_804.value().string(item_805.as_str());
}
}
array_804.finish();
}
if let Some(var_806) = &input.drop {
let mut array_807 = object.key("drop").start_array();
for item_808 in var_806 {
{
array_807.value().string(item_808.as_str());
}
}
array_807.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_device(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Device,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_809) = &input.host_path {
object.key("hostPath").string(var_809.as_str());
}
if let Some(var_810) = &input.container_path {
object.key("containerPath").string(var_810.as_str());
}
if let Some(var_811) = &input.permissions {
let mut array_812 = object.key("permissions").start_array();
for item_813 in var_811 {
{
array_812.value().string(item_813.as_str());
}
}
array_812.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tmpfs(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tmpfs,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_814) = &input.container_path {
object.key("containerPath").string(var_814.as_str());
}
{
object.key("size").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.size).into()),
);
}
if let Some(var_815) = &input.mount_options {
let mut array_816 = object.key("mountOptions").start_array();
for item_817 in var_815 {
{
array_816.value().string(item_817.as_str());
}
}
array_816.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_efs_authorization_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EfsAuthorizationConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_818) = &input.access_point_id {
object.key("accessPointId").string(var_818.as_str());
}
if let Some(var_819) = &input.iam {
object.key("iam").string(var_819.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_f_sx_windows_file_server_authorization_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FSxWindowsFileServerAuthorizationConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_820) = &input.credentials_parameter {
object.key("credentialsParameter").string(var_820.as_str());
}
if let Some(var_821) = &input.domain {
object.key("domain").string(var_821.as_str());
}
Ok(())
}