pub fn serialize_structure_crate_input_associate_service_role_to_account_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateServiceRoleToAccountInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.role_arn {
object.key("RoleArn").string(var_1.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_associate_client_device_with_core_device_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchAssociateClientDeviceWithCoreDeviceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2) = &input.entries {
let mut array_3 = object.key("entries").start_array();
for item_4 in var_2 {
{
#[allow(unused_mut)]
let mut object_5 = array_3.value().start_object();
crate::json_ser::serialize_structure_crate_model_associate_client_device_with_core_device_entry(&mut object_5, item_4)?;
object_5.finish();
}
}
array_3.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_disassociate_client_device_from_core_device_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchDisassociateClientDeviceFromCoreDeviceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_6) = &input.entries {
let mut array_7 = object.key("entries").start_array();
for item_8 in var_6 {
{
#[allow(unused_mut)]
let mut object_9 = array_7.value().start_object();
crate::json_ser::serialize_structure_crate_model_disassociate_client_device_from_core_device_entry(&mut object_9, item_8)?;
object_9.finish();
}
}
array_7.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_component_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateComponentVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_10) = &input.client_token {
object.key("clientToken").string(var_10.as_str());
}
if let Some(var_11) = &input.inline_recipe {
object
.key("inlineRecipe")
.string_unchecked(&aws_smithy_types::base64::encode(var_11));
}
if let Some(var_12) = &input.lambda_function {
#[allow(unused_mut)]
let mut object_13 = object.key("lambdaFunction").start_object();
crate::json_ser::serialize_structure_crate_model_lambda_function_recipe_source(
&mut object_13,
var_12,
)?;
object_13.finish();
}
if let Some(var_14) = &input.tags {
#[allow(unused_mut)]
let mut object_15 = object.key("tags").start_object();
for (key_16, value_17) in var_14 {
{
object_15.key(key_16.as_str()).string(value_17.as_str());
}
}
object_15.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_deployment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDeploymentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_18) = &input.client_token {
object.key("clientToken").string(var_18.as_str());
}
if let Some(var_19) = &input.components {
#[allow(unused_mut)]
let mut object_20 = object.key("components").start_object();
for (key_21, value_22) in var_19 {
{
#[allow(unused_mut)]
let mut object_23 = object_20.key(key_21.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_component_deployment_specification(&mut object_23, value_22)?;
object_23.finish();
}
}
object_20.finish();
}
if let Some(var_24) = &input.deployment_name {
object.key("deploymentName").string(var_24.as_str());
}
if let Some(var_25) = &input.deployment_policies {
#[allow(unused_mut)]
let mut object_26 = object.key("deploymentPolicies").start_object();
crate::json_ser::serialize_structure_crate_model_deployment_policies(
&mut object_26,
var_25,
)?;
object_26.finish();
}
if let Some(var_27) = &input.iot_job_configuration {
#[allow(unused_mut)]
let mut object_28 = object.key("iotJobConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_deployment_io_t_job_configuration(
&mut object_28,
var_27,
)?;
object_28.finish();
}
if let Some(var_29) = &input.parent_target_arn {
object.key("parentTargetArn").string(var_29.as_str());
}
if let Some(var_30) = &input.tags {
#[allow(unused_mut)]
let mut object_31 = object.key("tags").start_object();
for (key_32, value_33) in var_30 {
{
object_31.key(key_32.as_str()).string(value_33.as_str());
}
}
object_31.finish();
}
if let Some(var_34) = &input.target_arn {
object.key("targetArn").string(var_34.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_resolve_component_candidates_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ResolveComponentCandidatesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_35) = &input.component_candidates {
let mut array_36 = object.key("componentCandidates").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_component_candidate(
&mut object_38,
item_37,
)?;
object_38.finish();
}
}
array_36.finish();
}
if let Some(var_39) = &input.platform {
#[allow(unused_mut)]
let mut object_40 = object.key("platform").start_object();
crate::json_ser::serialize_structure_crate_model_component_platform(
&mut object_40,
var_39,
)?;
object_40.finish();
}
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_41) = &input.tags {
#[allow(unused_mut)]
let mut object_42 = object.key("tags").start_object();
for (key_43, value_44) in var_41 {
{
object_42.key(key_43.as_str()).string(value_44.as_str());
}
}
object_42.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_connectivity_info_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateConnectivityInfoInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_45) = &input.connectivity_info {
let mut array_46 = object.key("ConnectivityInfo").start_array();
for item_47 in var_45 {
{
#[allow(unused_mut)]
let mut object_48 = array_46.value().start_object();
crate::json_ser::serialize_structure_crate_model_connectivity_info(
&mut object_48,
item_47,
)?;
object_48.finish();
}
}
array_46.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_associate_client_device_with_core_device_entry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AssociateClientDeviceWithCoreDeviceEntry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_49) = &input.thing_name {
object.key("thingName").string(var_49.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_disassociate_client_device_from_core_device_entry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DisassociateClientDeviceFromCoreDeviceEntry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_50) = &input.thing_name {
object.key("thingName").string(var_50.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_lambda_function_recipe_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LambdaFunctionRecipeSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_51) = &input.lambda_arn {
object.key("lambdaArn").string(var_51.as_str());
}
if let Some(var_52) = &input.component_name {
object.key("componentName").string(var_52.as_str());
}
if let Some(var_53) = &input.component_version {
object.key("componentVersion").string(var_53.as_str());
}
if let Some(var_54) = &input.component_platforms {
let mut array_55 = object.key("componentPlatforms").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_component_platform(
&mut object_57,
item_56,
)?;
object_57.finish();
}
}
array_55.finish();
}
if let Some(var_58) = &input.component_dependencies {
#[allow(unused_mut)]
let mut object_59 = object.key("componentDependencies").start_object();
for (key_60, value_61) in var_58 {
{
#[allow(unused_mut)]
let mut object_62 = object_59.key(key_60.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_component_dependency_requirement(
&mut object_62,
value_61,
)?;
object_62.finish();
}
}
object_59.finish();
}
if let Some(var_63) = &input.component_lambda_parameters {
#[allow(unused_mut)]
let mut object_64 = object.key("componentLambdaParameters").start_object();
crate::json_ser::serialize_structure_crate_model_lambda_execution_parameters(
&mut object_64,
var_63,
)?;
object_64.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_component_deployment_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComponentDeploymentSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_65) = &input.component_version {
object.key("componentVersion").string(var_65.as_str());
}
if let Some(var_66) = &input.configuration_update {
#[allow(unused_mut)]
let mut object_67 = object.key("configurationUpdate").start_object();
crate::json_ser::serialize_structure_crate_model_component_configuration_update(
&mut object_67,
var_66,
)?;
object_67.finish();
}
if let Some(var_68) = &input.run_with {
#[allow(unused_mut)]
let mut object_69 = object.key("runWith").start_object();
crate::json_ser::serialize_structure_crate_model_component_run_with(
&mut object_69,
var_68,
)?;
object_69.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_deployment_policies(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeploymentPolicies,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_70) = &input.failure_handling_policy {
object.key("failureHandlingPolicy").string(var_70.as_str());
}
if let Some(var_71) = &input.component_update_policy {
#[allow(unused_mut)]
let mut object_72 = object.key("componentUpdatePolicy").start_object();
crate::json_ser::serialize_structure_crate_model_deployment_component_update_policy(
&mut object_72,
var_71,
)?;
object_72.finish();
}
if let Some(var_73) = &input.configuration_validation_policy {
#[allow(unused_mut)]
let mut object_74 = object.key("configurationValidationPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_deployment_configuration_validation_policy(&mut object_74, var_73)?;
object_74.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_deployment_io_t_job_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeploymentIoTJobConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_75) = &input.job_executions_rollout_config {
#[allow(unused_mut)]
let mut object_76 = object.key("jobExecutionsRolloutConfig").start_object();
crate::json_ser::serialize_structure_crate_model_io_t_job_executions_rollout_config(
&mut object_76,
var_75,
)?;
object_76.finish();
}
if let Some(var_77) = &input.abort_config {
#[allow(unused_mut)]
let mut object_78 = object.key("abortConfig").start_object();
crate::json_ser::serialize_structure_crate_model_io_t_job_abort_config(
&mut object_78,
var_77,
)?;
object_78.finish();
}
if let Some(var_79) = &input.timeout_config {
#[allow(unused_mut)]
let mut object_80 = object.key("timeoutConfig").start_object();
crate::json_ser::serialize_structure_crate_model_io_t_job_timeout_config(
&mut object_80,
var_79,
)?;
object_80.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_component_candidate(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComponentCandidate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_81) = &input.component_name {
object.key("componentName").string(var_81.as_str());
}
if let Some(var_82) = &input.component_version {
object.key("componentVersion").string(var_82.as_str());
}
if let Some(var_83) = &input.version_requirements {
#[allow(unused_mut)]
let mut object_84 = object.key("versionRequirements").start_object();
for (key_85, value_86) in var_83 {
{
object_84.key(key_85.as_str()).string(value_86.as_str());
}
}
object_84.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_component_platform(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComponentPlatform,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_87) = &input.name {
object.key("name").string(var_87.as_str());
}
if let Some(var_88) = &input.attributes {
#[allow(unused_mut)]
let mut object_89 = object.key("attributes").start_object();
for (key_90, value_91) in var_88 {
{
object_89.key(key_90.as_str()).string(value_91.as_str());
}
}
object_89.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_connectivity_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConnectivityInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_92) = &input.id {
object.key("Id").string(var_92.as_str());
}
if let Some(var_93) = &input.host_address {
object.key("HostAddress").string(var_93.as_str());
}
if input.port_number != 0 {
object.key("PortNumber").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port_number).into()),
);
}
if let Some(var_94) = &input.metadata {
object.key("Metadata").string(var_94.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_component_dependency_requirement(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComponentDependencyRequirement,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_95) = &input.version_requirement {
object.key("versionRequirement").string(var_95.as_str());
}
if let Some(var_96) = &input.dependency_type {
object.key("dependencyType").string(var_96.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_lambda_execution_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LambdaExecutionParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_97) = &input.event_sources {
let mut array_98 = object.key("eventSources").start_array();
for item_99 in var_97 {
{
#[allow(unused_mut)]
let mut object_100 = array_98.value().start_object();
crate::json_ser::serialize_structure_crate_model_lambda_event_source(
&mut object_100,
item_99,
)?;
object_100.finish();
}
}
array_98.finish();
}
if let Some(var_101) = &input.max_queue_size {
object.key("maxQueueSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_101).into()),
);
}
if let Some(var_102) = &input.max_instances_count {
object.key("maxInstancesCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_102).into()),
);
}
if let Some(var_103) = &input.max_idle_time_in_seconds {
object.key("maxIdleTimeInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_103).into()),
);
}
if let Some(var_104) = &input.timeout_in_seconds {
object.key("timeoutInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_104).into()),
);
}
if let Some(var_105) = &input.status_timeout_in_seconds {
object.key("statusTimeoutInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_105).into()),
);
}
if let Some(var_106) = &input.pinned {
object.key("pinned").boolean(*var_106);
}
if let Some(var_107) = &input.input_payload_encoding_type {
object
.key("inputPayloadEncodingType")
.string(var_107.as_str());
}
if let Some(var_108) = &input.exec_args {
let mut array_109 = object.key("execArgs").start_array();
for item_110 in var_108 {
{
array_109.value().string(item_110.as_str());
}
}
array_109.finish();
}
if let Some(var_111) = &input.environment_variables {
#[allow(unused_mut)]
let mut object_112 = object.key("environmentVariables").start_object();
for (key_113, value_114) in var_111 {
{
object_112.key(key_113.as_str()).string(value_114.as_str());
}
}
object_112.finish();
}
if let Some(var_115) = &input.linux_process_params {
#[allow(unused_mut)]
let mut object_116 = object.key("linuxProcessParams").start_object();
crate::json_ser::serialize_structure_crate_model_lambda_linux_process_params(
&mut object_116,
var_115,
)?;
object_116.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_component_configuration_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComponentConfigurationUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_117) = &input.merge {
object.key("merge").string(var_117.as_str());
}
if let Some(var_118) = &input.reset {
let mut array_119 = object.key("reset").start_array();
for item_120 in var_118 {
{
array_119.value().string(item_120.as_str());
}
}
array_119.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_component_run_with(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComponentRunWith,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_121) = &input.posix_user {
object.key("posixUser").string(var_121.as_str());
}
if let Some(var_122) = &input.system_resource_limits {
#[allow(unused_mut)]
let mut object_123 = object.key("systemResourceLimits").start_object();
crate::json_ser::serialize_structure_crate_model_system_resource_limits(
&mut object_123,
var_122,
)?;
object_123.finish();
}
if let Some(var_124) = &input.windows_user {
object.key("windowsUser").string(var_124.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_deployment_component_update_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeploymentComponentUpdatePolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_125) = &input.timeout_in_seconds {
object.key("timeoutInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_125).into()),
);
}
if let Some(var_126) = &input.action {
object.key("action").string(var_126.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_deployment_configuration_validation_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeploymentConfigurationValidationPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_127) = &input.timeout_in_seconds {
object.key("timeoutInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_127).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_io_t_job_executions_rollout_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IoTJobExecutionsRolloutConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_128) = &input.exponential_rate {
#[allow(unused_mut)]
let mut object_129 = object.key("exponentialRate").start_object();
crate::json_ser::serialize_structure_crate_model_io_t_job_exponential_rollout_rate(
&mut object_129,
var_128,
)?;
object_129.finish();
}
if let Some(var_130) = &input.maximum_per_minute {
object.key("maximumPerMinute").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_130).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_io_t_job_abort_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IoTJobAbortConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_131) = &input.criteria_list {
let mut array_132 = object.key("criteriaList").start_array();
for item_133 in var_131 {
{
#[allow(unused_mut)]
let mut object_134 = array_132.value().start_object();
crate::json_ser::serialize_structure_crate_model_io_t_job_abort_criteria(
&mut object_134,
item_133,
)?;
object_134.finish();
}
}
array_132.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_io_t_job_timeout_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IoTJobTimeoutConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_135) = &input.in_progress_timeout_in_minutes {
object.key("inProgressTimeoutInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_135).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_lambda_event_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LambdaEventSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_136) = &input.topic {
object.key("topic").string(var_136.as_str());
}
if let Some(var_137) = &input.r#type {
object.key("type").string(var_137.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_lambda_linux_process_params(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LambdaLinuxProcessParams,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_138) = &input.isolation_mode {
object.key("isolationMode").string(var_138.as_str());
}
if let Some(var_139) = &input.container_params {
#[allow(unused_mut)]
let mut object_140 = object.key("containerParams").start_object();
crate::json_ser::serialize_structure_crate_model_lambda_container_params(
&mut object_140,
var_139,
)?;
object_140.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_system_resource_limits(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SystemResourceLimits,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.memory != 0 {
object.key("memory").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.memory).into()),
);
}
if input.cpus != 0.0 {
object.key("cpus").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.cpus).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_io_t_job_exponential_rollout_rate(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IoTJobExponentialRolloutRate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("baseRatePerMinute").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.base_rate_per_minute).into()),
);
}
{
object.key("incrementFactor").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.increment_factor).into()),
);
}
if let Some(var_141) = &input.rate_increase_criteria {
#[allow(unused_mut)]
let mut object_142 = object.key("rateIncreaseCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_io_t_job_rate_increase_criteria(
&mut object_142,
var_141,
)?;
object_142.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_io_t_job_abort_criteria(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IoTJobAbortCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_143) = &input.failure_type {
object.key("failureType").string(var_143.as_str());
}
if let Some(var_144) = &input.action {
object.key("action").string(var_144.as_str());
}
{
object.key("thresholdPercentage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.threshold_percentage).into()),
);
}
{
object.key("minNumberOfExecutedThings").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.min_number_of_executed_things).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_lambda_container_params(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LambdaContainerParams,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_145) = &input.memory_size_in_kb {
object.key("memorySizeInKB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_145).into()),
);
}
if let Some(var_146) = &input.mount_ro_sysfs {
object.key("mountROSysfs").boolean(*var_146);
}
if let Some(var_147) = &input.volumes {
let mut array_148 = object.key("volumes").start_array();
for item_149 in var_147 {
{
#[allow(unused_mut)]
let mut object_150 = array_148.value().start_object();
crate::json_ser::serialize_structure_crate_model_lambda_volume_mount(
&mut object_150,
item_149,
)?;
object_150.finish();
}
}
array_148.finish();
}
if let Some(var_151) = &input.devices {
let mut array_152 = object.key("devices").start_array();
for item_153 in var_151 {
{
#[allow(unused_mut)]
let mut object_154 = array_152.value().start_object();
crate::json_ser::serialize_structure_crate_model_lambda_device_mount(
&mut object_154,
item_153,
)?;
object_154.finish();
}
}
array_152.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_io_t_job_rate_increase_criteria(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IoTJobRateIncreaseCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_155) = &input.number_of_notified_things {
object.key("numberOfNotifiedThings").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_155).into()),
);
}
if let Some(var_156) = &input.number_of_succeeded_things {
object.key("numberOfSucceededThings").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_156).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_lambda_volume_mount(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LambdaVolumeMount,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_157) = &input.source_path {
object.key("sourcePath").string(var_157.as_str());
}
if let Some(var_158) = &input.destination_path {
object.key("destinationPath").string(var_158.as_str());
}
if let Some(var_159) = &input.permission {
object.key("permission").string(var_159.as_str());
}
if let Some(var_160) = &input.add_group_owner {
object.key("addGroupOwner").boolean(*var_160);
}
Ok(())
}
pub fn serialize_structure_crate_model_lambda_device_mount(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LambdaDeviceMount,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_161) = &input.path {
object.key("path").string(var_161.as_str());
}
if let Some(var_162) = &input.permission {
object.key("permission").string(var_162.as_str());
}
if let Some(var_163) = &input.add_group_owner {
object.key("addGroupOwner").boolean(*var_163);
}
Ok(())
}