pub fn serialize_structure_crate_input_associate_role_to_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateRoleToGroupInput,
) -> 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_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_2) = &input.role_arn {
object.key("RoleArn").string(var_2.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_connector_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateConnectorDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3) = &input.initial_version {
#[allow(unused_mut)]
let mut object_4 = object.key("InitialVersion").start_object();
crate::json_ser::serialize_structure_crate_model_connector_definition_version(
&mut object_4,
var_3,
)?;
object_4.finish();
}
if let Some(var_5) = &input.name {
object.key("Name").string(var_5.as_str());
}
if let Some(var_6) = &input.tags {
#[allow(unused_mut)]
let mut object_7 = object.key("tags").start_object();
for (key_8, value_9) in var_6 {
{
object_7.key(key_8.as_str()).string(value_9.as_str());
}
}
object_7.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_connector_definition_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateConnectorDefinitionVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_10) = &input.connectors {
let mut array_11 = object.key("Connectors").start_array();
for item_12 in var_10 {
{
#[allow(unused_mut)]
let mut object_13 = array_11.value().start_object();
crate::json_ser::serialize_structure_crate_model_connector(
&mut object_13,
item_12,
)?;
object_13.finish();
}
}
array_11.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_core_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateCoreDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_14) = &input.initial_version {
#[allow(unused_mut)]
let mut object_15 = object.key("InitialVersion").start_object();
crate::json_ser::serialize_structure_crate_model_core_definition_version(
&mut object_15,
var_14,
)?;
object_15.finish();
}
if let Some(var_16) = &input.name {
object.key("Name").string(var_16.as_str());
}
if let Some(var_17) = &input.tags {
#[allow(unused_mut)]
let mut object_18 = object.key("tags").start_object();
for (key_19, value_20) in var_17 {
{
object_18.key(key_19.as_str()).string(value_20.as_str());
}
}
object_18.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_core_definition_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateCoreDefinitionVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_21) = &input.cores {
let mut array_22 = object.key("Cores").start_array();
for item_23 in var_21 {
{
#[allow(unused_mut)]
let mut object_24 = array_22.value().start_object();
crate::json_ser::serialize_structure_crate_model_core(&mut object_24, item_23)?;
object_24.finish();
}
}
array_22.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_25) = &input.deployment_id {
object.key("DeploymentId").string(var_25.as_str());
}
if let Some(var_26) = &input.deployment_type {
object.key("DeploymentType").string(var_26.as_str());
}
if let Some(var_27) = &input.group_version_id {
object.key("GroupVersionId").string(var_27.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_device_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDeviceDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_28) = &input.initial_version {
#[allow(unused_mut)]
let mut object_29 = object.key("InitialVersion").start_object();
crate::json_ser::serialize_structure_crate_model_device_definition_version(
&mut object_29,
var_28,
)?;
object_29.finish();
}
if let Some(var_30) = &input.name {
object.key("Name").string(var_30.as_str());
}
if let Some(var_31) = &input.tags {
#[allow(unused_mut)]
let mut object_32 = object.key("tags").start_object();
for (key_33, value_34) in var_31 {
{
object_32.key(key_33.as_str()).string(value_34.as_str());
}
}
object_32.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_device_definition_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDeviceDefinitionVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_35) = &input.devices {
let mut array_36 = object.key("Devices").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_device(&mut object_38, item_37)?;
object_38.finish();
}
}
array_36.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_function_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFunctionDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_39) = &input.initial_version {
#[allow(unused_mut)]
let mut object_40 = object.key("InitialVersion").start_object();
crate::json_ser::serialize_structure_crate_model_function_definition_version(
&mut object_40,
var_39,
)?;
object_40.finish();
}
if let Some(var_41) = &input.name {
object.key("Name").string(var_41.as_str());
}
if let Some(var_42) = &input.tags {
#[allow(unused_mut)]
let mut object_43 = object.key("tags").start_object();
for (key_44, value_45) in var_42 {
{
object_43.key(key_44.as_str()).string(value_45.as_str());
}
}
object_43.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_function_definition_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFunctionDefinitionVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_46) = &input.default_config {
#[allow(unused_mut)]
let mut object_47 = object.key("DefaultConfig").start_object();
crate::json_ser::serialize_structure_crate_model_function_default_config(
&mut object_47,
var_46,
)?;
object_47.finish();
}
if let Some(var_48) = &input.functions {
let mut array_49 = object.key("Functions").start_array();
for item_50 in var_48 {
{
#[allow(unused_mut)]
let mut object_51 = array_49.value().start_object();
crate::json_ser::serialize_structure_crate_model_function(&mut object_51, item_50)?;
object_51.finish();
}
}
array_49.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_52) = &input.initial_version {
#[allow(unused_mut)]
let mut object_53 = object.key("InitialVersion").start_object();
crate::json_ser::serialize_structure_crate_model_group_version(&mut object_53, var_52)?;
object_53.finish();
}
if let Some(var_54) = &input.name {
object.key("Name").string(var_54.as_str());
}
if let Some(var_55) = &input.tags {
#[allow(unused_mut)]
let mut object_56 = object.key("tags").start_object();
for (key_57, value_58) in var_55 {
{
object_56.key(key_57.as_str()).string(value_58.as_str());
}
}
object_56.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_group_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateGroupVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_59) = &input.connector_definition_version_arn {
object
.key("ConnectorDefinitionVersionArn")
.string(var_59.as_str());
}
if let Some(var_60) = &input.core_definition_version_arn {
object
.key("CoreDefinitionVersionArn")
.string(var_60.as_str());
}
if let Some(var_61) = &input.device_definition_version_arn {
object
.key("DeviceDefinitionVersionArn")
.string(var_61.as_str());
}
if let Some(var_62) = &input.function_definition_version_arn {
object
.key("FunctionDefinitionVersionArn")
.string(var_62.as_str());
}
if let Some(var_63) = &input.logger_definition_version_arn {
object
.key("LoggerDefinitionVersionArn")
.string(var_63.as_str());
}
if let Some(var_64) = &input.resource_definition_version_arn {
object
.key("ResourceDefinitionVersionArn")
.string(var_64.as_str());
}
if let Some(var_65) = &input.subscription_definition_version_arn {
object
.key("SubscriptionDefinitionVersionArn")
.string(var_65.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_logger_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLoggerDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_66) = &input.initial_version {
#[allow(unused_mut)]
let mut object_67 = object.key("InitialVersion").start_object();
crate::json_ser::serialize_structure_crate_model_logger_definition_version(
&mut object_67,
var_66,
)?;
object_67.finish();
}
if let Some(var_68) = &input.name {
object.key("Name").string(var_68.as_str());
}
if let Some(var_69) = &input.tags {
#[allow(unused_mut)]
let mut object_70 = object.key("tags").start_object();
for (key_71, value_72) in var_69 {
{
object_70.key(key_71.as_str()).string(value_72.as_str());
}
}
object_70.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_logger_definition_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLoggerDefinitionVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_73) = &input.loggers {
let mut array_74 = object.key("Loggers").start_array();
for item_75 in var_73 {
{
#[allow(unused_mut)]
let mut object_76 = array_74.value().start_object();
crate::json_ser::serialize_structure_crate_model_logger(&mut object_76, item_75)?;
object_76.finish();
}
}
array_74.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_resource_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateResourceDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_77) = &input.initial_version {
#[allow(unused_mut)]
let mut object_78 = object.key("InitialVersion").start_object();
crate::json_ser::serialize_structure_crate_model_resource_definition_version(
&mut object_78,
var_77,
)?;
object_78.finish();
}
if let Some(var_79) = &input.name {
object.key("Name").string(var_79.as_str());
}
if let Some(var_80) = &input.tags {
#[allow(unused_mut)]
let mut object_81 = object.key("tags").start_object();
for (key_82, value_83) in var_80 {
{
object_81.key(key_82.as_str()).string(value_83.as_str());
}
}
object_81.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_resource_definition_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateResourceDefinitionVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_84) = &input.resources {
let mut array_85 = object.key("Resources").start_array();
for item_86 in var_84 {
{
#[allow(unused_mut)]
let mut object_87 = array_85.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource(&mut object_87, item_86)?;
object_87.finish();
}
}
array_85.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_software_update_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSoftwareUpdateJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_88) = &input.s3_url_signer_role {
object.key("S3UrlSignerRole").string(var_88.as_str());
}
if let Some(var_89) = &input.software_to_update {
object.key("SoftwareToUpdate").string(var_89.as_str());
}
if let Some(var_90) = &input.update_agent_log_level {
object.key("UpdateAgentLogLevel").string(var_90.as_str());
}
if let Some(var_91) = &input.update_targets {
let mut array_92 = object.key("UpdateTargets").start_array();
for item_93 in var_91 {
{
array_92.value().string(item_93.as_str());
}
}
array_92.finish();
}
if let Some(var_94) = &input.update_targets_architecture {
object
.key("UpdateTargetsArchitecture")
.string(var_94.as_str());
}
if let Some(var_95) = &input.update_targets_operating_system {
object
.key("UpdateTargetsOperatingSystem")
.string(var_95.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_subscription_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSubscriptionDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_96) = &input.initial_version {
#[allow(unused_mut)]
let mut object_97 = object.key("InitialVersion").start_object();
crate::json_ser::serialize_structure_crate_model_subscription_definition_version(
&mut object_97,
var_96,
)?;
object_97.finish();
}
if let Some(var_98) = &input.name {
object.key("Name").string(var_98.as_str());
}
if let Some(var_99) = &input.tags {
#[allow(unused_mut)]
let mut object_100 = object.key("tags").start_object();
for (key_101, value_102) in var_99 {
{
object_100.key(key_101.as_str()).string(value_102.as_str());
}
}
object_100.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_subscription_definition_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSubscriptionDefinitionVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_103) = &input.subscriptions {
let mut array_104 = object.key("Subscriptions").start_array();
for item_105 in var_103 {
{
#[allow(unused_mut)]
let mut object_106 = array_104.value().start_object();
crate::json_ser::serialize_structure_crate_model_subscription(
&mut object_106,
item_105,
)?;
object_106.finish();
}
}
array_104.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_reset_deployments_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ResetDeploymentsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.force {
object.key("Force").boolean(input.force);
}
Ok(())
}
pub fn serialize_structure_crate_input_start_bulk_deployment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartBulkDeploymentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_107) = &input.execution_role_arn {
object.key("ExecutionRoleArn").string(var_107.as_str());
}
if let Some(var_108) = &input.input_file_uri {
object.key("InputFileUri").string(var_108.as_str());
}
if let Some(var_109) = &input.tags {
#[allow(unused_mut)]
let mut object_110 = object.key("tags").start_object();
for (key_111, value_112) in var_109 {
{
object_110.key(key_111.as_str()).string(value_112.as_str());
}
}
object_110.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_113) = &input.tags {
#[allow(unused_mut)]
let mut object_114 = object.key("tags").start_object();
for (key_115, value_116) in var_113 {
{
object_114.key(key_115.as_str()).string(value_116.as_str());
}
}
object_114.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_117) = &input.connectivity_info {
let mut array_118 = object.key("ConnectivityInfo").start_array();
for item_119 in var_117 {
{
#[allow(unused_mut)]
let mut object_120 = array_118.value().start_object();
crate::json_ser::serialize_structure_crate_model_connectivity_info(
&mut object_120,
item_119,
)?;
object_120.finish();
}
}
array_118.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_connector_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateConnectorDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_121) = &input.name {
object.key("Name").string(var_121.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_core_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateCoreDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_122) = &input.name {
object.key("Name").string(var_122.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_device_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDeviceDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_123) = &input.name {
object.key("Name").string(var_123.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_function_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFunctionDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_124) = &input.name {
object.key("Name").string(var_124.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_125) = &input.name {
object.key("Name").string(var_125.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_group_certificate_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateGroupCertificateConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_126) = &input.certificate_expiry_in_milliseconds {
object
.key("CertificateExpiryInMilliseconds")
.string(var_126.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_logger_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateLoggerDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_127) = &input.name {
object.key("Name").string(var_127.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_resource_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateResourceDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_128) = &input.name {
object.key("Name").string(var_128.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_subscription_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSubscriptionDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_129) = &input.name {
object.key("Name").string(var_129.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_thing_runtime_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateThingRuntimeConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_130) = &input.telemetry_configuration {
#[allow(unused_mut)]
let mut object_131 = object.key("TelemetryConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_telemetry_configuration_update(
&mut object_131,
var_130,
)?;
object_131.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_connector_definition_version(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConnectorDefinitionVersion,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_132) = &input.connectors {
let mut array_133 = object.key("Connectors").start_array();
for item_134 in var_132 {
{
#[allow(unused_mut)]
let mut object_135 = array_133.value().start_object();
crate::json_ser::serialize_structure_crate_model_connector(
&mut object_135,
item_134,
)?;
object_135.finish();
}
}
array_133.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_connector(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Connector,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_136) = &input.connector_arn {
object.key("ConnectorArn").string(var_136.as_str());
}
if let Some(var_137) = &input.id {
object.key("Id").string(var_137.as_str());
}
if let Some(var_138) = &input.parameters {
#[allow(unused_mut)]
let mut object_139 = object.key("Parameters").start_object();
for (key_140, value_141) in var_138 {
{
object_139.key(key_140.as_str()).string(value_141.as_str());
}
}
object_139.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_core_definition_version(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CoreDefinitionVersion,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_142) = &input.cores {
let mut array_143 = object.key("Cores").start_array();
for item_144 in var_142 {
{
#[allow(unused_mut)]
let mut object_145 = array_143.value().start_object();
crate::json_ser::serialize_structure_crate_model_core(&mut object_145, item_144)?;
object_145.finish();
}
}
array_143.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_core(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Core,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_146) = &input.certificate_arn {
object.key("CertificateArn").string(var_146.as_str());
}
if let Some(var_147) = &input.id {
object.key("Id").string(var_147.as_str());
}
if input.sync_shadow {
object.key("SyncShadow").boolean(input.sync_shadow);
}
if let Some(var_148) = &input.thing_arn {
object.key("ThingArn").string(var_148.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_device_definition_version(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeviceDefinitionVersion,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_149) = &input.devices {
let mut array_150 = object.key("Devices").start_array();
for item_151 in var_149 {
{
#[allow(unused_mut)]
let mut object_152 = array_150.value().start_object();
crate::json_ser::serialize_structure_crate_model_device(&mut object_152, item_151)?;
object_152.finish();
}
}
array_150.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_153) = &input.certificate_arn {
object.key("CertificateArn").string(var_153.as_str());
}
if let Some(var_154) = &input.id {
object.key("Id").string(var_154.as_str());
}
if input.sync_shadow {
object.key("SyncShadow").boolean(input.sync_shadow);
}
if let Some(var_155) = &input.thing_arn {
object.key("ThingArn").string(var_155.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_function_definition_version(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FunctionDefinitionVersion,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_156) = &input.default_config {
#[allow(unused_mut)]
let mut object_157 = object.key("DefaultConfig").start_object();
crate::json_ser::serialize_structure_crate_model_function_default_config(
&mut object_157,
var_156,
)?;
object_157.finish();
}
if let Some(var_158) = &input.functions {
let mut array_159 = object.key("Functions").start_array();
for item_160 in var_158 {
{
#[allow(unused_mut)]
let mut object_161 = array_159.value().start_object();
crate::json_ser::serialize_structure_crate_model_function(
&mut object_161,
item_160,
)?;
object_161.finish();
}
}
array_159.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_function_default_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FunctionDefaultConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_162) = &input.execution {
#[allow(unused_mut)]
let mut object_163 = object.key("Execution").start_object();
crate::json_ser::serialize_structure_crate_model_function_default_execution_config(
&mut object_163,
var_162,
)?;
object_163.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_function(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Function,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_164) = &input.function_arn {
object.key("FunctionArn").string(var_164.as_str());
}
if let Some(var_165) = &input.function_configuration {
#[allow(unused_mut)]
let mut object_166 = object.key("FunctionConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_function_configuration(
&mut object_166,
var_165,
)?;
object_166.finish();
}
if let Some(var_167) = &input.id {
object.key("Id").string(var_167.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_group_version(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GroupVersion,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_168) = &input.connector_definition_version_arn {
object
.key("ConnectorDefinitionVersionArn")
.string(var_168.as_str());
}
if let Some(var_169) = &input.core_definition_version_arn {
object
.key("CoreDefinitionVersionArn")
.string(var_169.as_str());
}
if let Some(var_170) = &input.device_definition_version_arn {
object
.key("DeviceDefinitionVersionArn")
.string(var_170.as_str());
}
if let Some(var_171) = &input.function_definition_version_arn {
object
.key("FunctionDefinitionVersionArn")
.string(var_171.as_str());
}
if let Some(var_172) = &input.logger_definition_version_arn {
object
.key("LoggerDefinitionVersionArn")
.string(var_172.as_str());
}
if let Some(var_173) = &input.resource_definition_version_arn {
object
.key("ResourceDefinitionVersionArn")
.string(var_173.as_str());
}
if let Some(var_174) = &input.subscription_definition_version_arn {
object
.key("SubscriptionDefinitionVersionArn")
.string(var_174.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_logger_definition_version(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoggerDefinitionVersion,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_175) = &input.loggers {
let mut array_176 = object.key("Loggers").start_array();
for item_177 in var_175 {
{
#[allow(unused_mut)]
let mut object_178 = array_176.value().start_object();
crate::json_ser::serialize_structure_crate_model_logger(&mut object_178, item_177)?;
object_178.finish();
}
}
array_176.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_logger(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Logger,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_179) = &input.component {
object.key("Component").string(var_179.as_str());
}
if let Some(var_180) = &input.id {
object.key("Id").string(var_180.as_str());
}
if let Some(var_181) = &input.level {
object.key("Level").string(var_181.as_str());
}
if input.space != 0 {
object.key("Space").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.space).into()),
);
}
if let Some(var_182) = &input.r#type {
object.key("Type").string(var_182.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_definition_version(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourceDefinitionVersion,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_183) = &input.resources {
let mut array_184 = object.key("Resources").start_array();
for item_185 in var_183 {
{
#[allow(unused_mut)]
let mut object_186 = array_184.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource(
&mut object_186,
item_185,
)?;
object_186.finish();
}
}
array_184.finish();
}
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_187) = &input.id {
object.key("Id").string(var_187.as_str());
}
if let Some(var_188) = &input.name {
object.key("Name").string(var_188.as_str());
}
if let Some(var_189) = &input.resource_data_container {
#[allow(unused_mut)]
let mut object_190 = object.key("ResourceDataContainer").start_object();
crate::json_ser::serialize_structure_crate_model_resource_data_container(
&mut object_190,
var_189,
)?;
object_190.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_subscription_definition_version(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SubscriptionDefinitionVersion,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_191) = &input.subscriptions {
let mut array_192 = object.key("Subscriptions").start_array();
for item_193 in var_191 {
{
#[allow(unused_mut)]
let mut object_194 = array_192.value().start_object();
crate::json_ser::serialize_structure_crate_model_subscription(
&mut object_194,
item_193,
)?;
object_194.finish();
}
}
array_192.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_subscription(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Subscription,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_195) = &input.id {
object.key("Id").string(var_195.as_str());
}
if let Some(var_196) = &input.source {
object.key("Source").string(var_196.as_str());
}
if let Some(var_197) = &input.subject {
object.key("Subject").string(var_197.as_str());
}
if let Some(var_198) = &input.target {
object.key("Target").string(var_198.as_str());
}
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_199) = &input.host_address {
object.key("HostAddress").string(var_199.as_str());
}
if let Some(var_200) = &input.id {
object.key("Id").string(var_200.as_str());
}
if let Some(var_201) = &input.metadata {
object.key("Metadata").string(var_201.as_str());
}
if input.port_number != 0 {
object.key("PortNumber").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port_number).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_telemetry_configuration_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TelemetryConfigurationUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_202) = &input.telemetry {
object.key("Telemetry").string(var_202.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_function_default_execution_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FunctionDefaultExecutionConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_203) = &input.isolation_mode {
object.key("IsolationMode").string(var_203.as_str());
}
if let Some(var_204) = &input.run_as {
#[allow(unused_mut)]
let mut object_205 = object.key("RunAs").start_object();
crate::json_ser::serialize_structure_crate_model_function_run_as_config(
&mut object_205,
var_204,
)?;
object_205.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_function_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FunctionConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_206) = &input.encoding_type {
object.key("EncodingType").string(var_206.as_str());
}
if let Some(var_207) = &input.environment {
#[allow(unused_mut)]
let mut object_208 = object.key("Environment").start_object();
crate::json_ser::serialize_structure_crate_model_function_configuration_environment(
&mut object_208,
var_207,
)?;
object_208.finish();
}
if let Some(var_209) = &input.exec_args {
object.key("ExecArgs").string(var_209.as_str());
}
if let Some(var_210) = &input.executable {
object.key("Executable").string(var_210.as_str());
}
if input.memory_size != 0 {
object.key("MemorySize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.memory_size).into()),
);
}
if input.pinned {
object.key("Pinned").boolean(input.pinned);
}
if input.timeout != 0 {
object.key("Timeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.timeout).into()),
);
}
if let Some(var_211) = &input.function_runtime_override {
object
.key("FunctionRuntimeOverride")
.string(var_211.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_data_container(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourceDataContainer,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_212) = &input.local_device_resource_data {
#[allow(unused_mut)]
let mut object_213 = object.key("LocalDeviceResourceData").start_object();
crate::json_ser::serialize_structure_crate_model_local_device_resource_data(
&mut object_213,
var_212,
)?;
object_213.finish();
}
if let Some(var_214) = &input.local_volume_resource_data {
#[allow(unused_mut)]
let mut object_215 = object.key("LocalVolumeResourceData").start_object();
crate::json_ser::serialize_structure_crate_model_local_volume_resource_data(
&mut object_215,
var_214,
)?;
object_215.finish();
}
if let Some(var_216) = &input.s3_machine_learning_model_resource_data {
#[allow(unused_mut)]
let mut object_217 = object
.key("S3MachineLearningModelResourceData")
.start_object();
crate::json_ser::serialize_structure_crate_model_s3_machine_learning_model_resource_data(
&mut object_217,
var_216,
)?;
object_217.finish();
}
if let Some(var_218) = &input.sage_maker_machine_learning_model_resource_data {
#[allow(unused_mut)]
let mut object_219 = object
.key("SageMakerMachineLearningModelResourceData")
.start_object();
crate::json_ser::serialize_structure_crate_model_sage_maker_machine_learning_model_resource_data(&mut object_219, var_218)?;
object_219.finish();
}
if let Some(var_220) = &input.secrets_manager_secret_resource_data {
#[allow(unused_mut)]
let mut object_221 = object
.key("SecretsManagerSecretResourceData")
.start_object();
crate::json_ser::serialize_structure_crate_model_secrets_manager_secret_resource_data(
&mut object_221,
var_220,
)?;
object_221.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_function_run_as_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FunctionRunAsConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.gid != 0 {
object.key("Gid").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.gid).into()),
);
}
if input.uid != 0 {
object.key("Uid").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.uid).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_function_configuration_environment(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FunctionConfigurationEnvironment,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.access_sysfs {
object.key("AccessSysfs").boolean(input.access_sysfs);
}
if let Some(var_222) = &input.execution {
#[allow(unused_mut)]
let mut object_223 = object.key("Execution").start_object();
crate::json_ser::serialize_structure_crate_model_function_execution_config(
&mut object_223,
var_222,
)?;
object_223.finish();
}
if let Some(var_224) = &input.resource_access_policies {
let mut array_225 = object.key("ResourceAccessPolicies").start_array();
for item_226 in var_224 {
{
#[allow(unused_mut)]
let mut object_227 = array_225.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_access_policy(
&mut object_227,
item_226,
)?;
object_227.finish();
}
}
array_225.finish();
}
if let Some(var_228) = &input.variables {
#[allow(unused_mut)]
let mut object_229 = object.key("Variables").start_object();
for (key_230, value_231) in var_228 {
{
object_229.key(key_230.as_str()).string(value_231.as_str());
}
}
object_229.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_local_device_resource_data(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LocalDeviceResourceData,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_232) = &input.group_owner_setting {
#[allow(unused_mut)]
let mut object_233 = object.key("GroupOwnerSetting").start_object();
crate::json_ser::serialize_structure_crate_model_group_owner_setting(
&mut object_233,
var_232,
)?;
object_233.finish();
}
if let Some(var_234) = &input.source_path {
object.key("SourcePath").string(var_234.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_local_volume_resource_data(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LocalVolumeResourceData,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_235) = &input.destination_path {
object.key("DestinationPath").string(var_235.as_str());
}
if let Some(var_236) = &input.group_owner_setting {
#[allow(unused_mut)]
let mut object_237 = object.key("GroupOwnerSetting").start_object();
crate::json_ser::serialize_structure_crate_model_group_owner_setting(
&mut object_237,
var_236,
)?;
object_237.finish();
}
if let Some(var_238) = &input.source_path {
object.key("SourcePath").string(var_238.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_machine_learning_model_resource_data(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3MachineLearningModelResourceData,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_239) = &input.destination_path {
object.key("DestinationPath").string(var_239.as_str());
}
if let Some(var_240) = &input.owner_setting {
#[allow(unused_mut)]
let mut object_241 = object.key("OwnerSetting").start_object();
crate::json_ser::serialize_structure_crate_model_resource_download_owner_setting(
&mut object_241,
var_240,
)?;
object_241.finish();
}
if let Some(var_242) = &input.s3_uri {
object.key("S3Uri").string(var_242.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sage_maker_machine_learning_model_resource_data(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SageMakerMachineLearningModelResourceData,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_243) = &input.destination_path {
object.key("DestinationPath").string(var_243.as_str());
}
if let Some(var_244) = &input.owner_setting {
#[allow(unused_mut)]
let mut object_245 = object.key("OwnerSetting").start_object();
crate::json_ser::serialize_structure_crate_model_resource_download_owner_setting(
&mut object_245,
var_244,
)?;
object_245.finish();
}
if let Some(var_246) = &input.sage_maker_job_arn {
object.key("SageMakerJobArn").string(var_246.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_secrets_manager_secret_resource_data(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SecretsManagerSecretResourceData,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_247) = &input.arn {
object.key("ARN").string(var_247.as_str());
}
if let Some(var_248) = &input.additional_staging_labels_to_download {
let mut array_249 = object
.key("AdditionalStagingLabelsToDownload")
.start_array();
for item_250 in var_248 {
{
array_249.value().string(item_250.as_str());
}
}
array_249.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_function_execution_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FunctionExecutionConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_251) = &input.isolation_mode {
object.key("IsolationMode").string(var_251.as_str());
}
if let Some(var_252) = &input.run_as {
#[allow(unused_mut)]
let mut object_253 = object.key("RunAs").start_object();
crate::json_ser::serialize_structure_crate_model_function_run_as_config(
&mut object_253,
var_252,
)?;
object_253.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_access_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourceAccessPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_254) = &input.permission {
object.key("Permission").string(var_254.as_str());
}
if let Some(var_255) = &input.resource_id {
object.key("ResourceId").string(var_255.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_group_owner_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GroupOwnerSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.auto_add_group_owner {
object
.key("AutoAddGroupOwner")
.boolean(input.auto_add_group_owner);
}
if let Some(var_256) = &input.group_owner {
object.key("GroupOwner").string(var_256.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_download_owner_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourceDownloadOwnerSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_257) = &input.group_owner {
object.key("GroupOwner").string(var_257.as_str());
}
if let Some(var_258) = &input.group_permission {
object.key("GroupPermission").string(var_258.as_str());
}
Ok(())
}