pub fn serialize_structure_crate_input_associate_assets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateAssetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.child_asset_id {
object.key("childAssetId").string(var_1.as_str());
}
if let Some(var_2) = &input.client_token {
object.key("clientToken").string(var_2.as_str());
}
if let Some(var_3) = &input.hierarchy_id {
object.key("hierarchyId").string(var_3.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_time_series_to_asset_property_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateTimeSeriesToAssetPropertyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_4) = &input.client_token {
object.key("clientToken").string(var_4.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_associate_project_assets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchAssociateProjectAssetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_5) = &input.asset_ids {
let mut array_6 = object.key("assetIds").start_array();
for item_7 in var_5 {
{
array_6.value().string(item_7.as_str());
}
}
array_6.finish();
}
if let Some(var_8) = &input.client_token {
object.key("clientToken").string(var_8.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_disassociate_project_assets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchDisassociateProjectAssetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_9) = &input.asset_ids {
let mut array_10 = object.key("assetIds").start_array();
for item_11 in var_9 {
{
array_10.value().string(item_11.as_str());
}
}
array_10.finish();
}
if let Some(var_12) = &input.client_token {
object.key("clientToken").string(var_12.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_get_asset_property_aggregates_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGetAssetPropertyAggregatesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_13) = &input.entries {
let mut array_14 = object.key("entries").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_batch_get_asset_property_aggregates_entry(&mut object_16, item_15)?;
object_16.finish();
}
}
array_14.finish();
}
if let Some(var_17) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_17).into()),
);
}
if let Some(var_18) = &input.next_token {
object.key("nextToken").string(var_18.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_get_asset_property_value_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGetAssetPropertyValueInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_19) = &input.entries {
let mut array_20 = object.key("entries").start_array();
for item_21 in var_19 {
{
#[allow(unused_mut)]
let mut object_22 = array_20.value().start_object();
crate::json_ser::serialize_structure_crate_model_batch_get_asset_property_value_entry(&mut object_22, item_21)?;
object_22.finish();
}
}
array_20.finish();
}
if let Some(var_23) = &input.next_token {
object.key("nextToken").string(var_23.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_get_asset_property_value_history_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGetAssetPropertyValueHistoryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_24) = &input.entries {
let mut array_25 = object.key("entries").start_array();
for item_26 in var_24 {
{
#[allow(unused_mut)]
let mut object_27 = array_25.value().start_object();
crate::json_ser::serialize_structure_crate_model_batch_get_asset_property_value_history_entry(&mut object_27, item_26)?;
object_27.finish();
}
}
array_25.finish();
}
if let Some(var_28) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_28).into()),
);
}
if let Some(var_29) = &input.next_token {
object.key("nextToken").string(var_29.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_put_asset_property_value_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchPutAssetPropertyValueInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_30) = &input.entries {
let mut array_31 = object.key("entries").start_array();
for item_32 in var_30 {
{
#[allow(unused_mut)]
let mut object_33 = array_31.value().start_object();
crate::json_ser::serialize_structure_crate_model_put_asset_property_value_entry(
&mut object_33,
item_32,
)?;
object_33.finish();
}
}
array_31.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_access_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAccessPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_34) = &input.access_policy_identity {
#[allow(unused_mut)]
let mut object_35 = object.key("accessPolicyIdentity").start_object();
crate::json_ser::serialize_structure_crate_model_identity(&mut object_35, var_34)?;
object_35.finish();
}
if let Some(var_36) = &input.access_policy_permission {
object.key("accessPolicyPermission").string(var_36.as_str());
}
if let Some(var_37) = &input.access_policy_resource {
#[allow(unused_mut)]
let mut object_38 = object.key("accessPolicyResource").start_object();
crate::json_ser::serialize_structure_crate_model_resource(&mut object_38, var_37)?;
object_38.finish();
}
if let Some(var_39) = &input.client_token {
object.key("clientToken").string(var_39.as_str());
}
if let Some(var_40) = &input.tags {
#[allow(unused_mut)]
let mut object_41 = object.key("tags").start_object();
for (key_42, value_43) in var_40 {
{
object_41.key(key_42.as_str()).string(value_43.as_str());
}
}
object_41.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_asset_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAssetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_44) = &input.asset_description {
object.key("assetDescription").string(var_44.as_str());
}
if let Some(var_45) = &input.asset_model_id {
object.key("assetModelId").string(var_45.as_str());
}
if let Some(var_46) = &input.asset_name {
object.key("assetName").string(var_46.as_str());
}
if let Some(var_47) = &input.client_token {
object.key("clientToken").string(var_47.as_str());
}
if let Some(var_48) = &input.tags {
#[allow(unused_mut)]
let mut object_49 = object.key("tags").start_object();
for (key_50, value_51) in var_48 {
{
object_49.key(key_50.as_str()).string(value_51.as_str());
}
}
object_49.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_asset_model_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAssetModelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_52) = &input.asset_model_composite_models {
let mut array_53 = object.key("assetModelCompositeModels").start_array();
for item_54 in var_52 {
{
#[allow(unused_mut)]
let mut object_55 = array_53.value().start_object();
crate::json_ser::serialize_structure_crate_model_asset_model_composite_model_definition(&mut object_55, item_54)?;
object_55.finish();
}
}
array_53.finish();
}
if let Some(var_56) = &input.asset_model_description {
object.key("assetModelDescription").string(var_56.as_str());
}
if let Some(var_57) = &input.asset_model_hierarchies {
let mut array_58 = object.key("assetModelHierarchies").start_array();
for item_59 in var_57 {
{
#[allow(unused_mut)]
let mut object_60 = array_58.value().start_object();
crate::json_ser::serialize_structure_crate_model_asset_model_hierarchy_definition(
&mut object_60,
item_59,
)?;
object_60.finish();
}
}
array_58.finish();
}
if let Some(var_61) = &input.asset_model_name {
object.key("assetModelName").string(var_61.as_str());
}
if let Some(var_62) = &input.asset_model_properties {
let mut array_63 = object.key("assetModelProperties").start_array();
for item_64 in var_62 {
{
#[allow(unused_mut)]
let mut object_65 = array_63.value().start_object();
crate::json_ser::serialize_structure_crate_model_asset_model_property_definition(
&mut object_65,
item_64,
)?;
object_65.finish();
}
}
array_63.finish();
}
if let Some(var_66) = &input.client_token {
object.key("clientToken").string(var_66.as_str());
}
if let Some(var_67) = &input.tags {
#[allow(unused_mut)]
let mut object_68 = object.key("tags").start_object();
for (key_69, value_70) in var_67 {
{
object_68.key(key_69.as_str()).string(value_70.as_str());
}
}
object_68.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_bulk_import_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBulkImportJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_71) = &input.error_report_location {
#[allow(unused_mut)]
let mut object_72 = object.key("errorReportLocation").start_object();
crate::json_ser::serialize_structure_crate_model_error_report_location(
&mut object_72,
var_71,
)?;
object_72.finish();
}
if let Some(var_73) = &input.files {
let mut array_74 = object.key("files").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_file(&mut object_76, item_75)?;
object_76.finish();
}
}
array_74.finish();
}
if let Some(var_77) = &input.job_configuration {
#[allow(unused_mut)]
let mut object_78 = object.key("jobConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_job_configuration(&mut object_78, var_77)?;
object_78.finish();
}
if let Some(var_79) = &input.job_name {
object.key("jobName").string(var_79.as_str());
}
if let Some(var_80) = &input.job_role_arn {
object.key("jobRoleArn").string(var_80.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_dashboard_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDashboardInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_81) = &input.client_token {
object.key("clientToken").string(var_81.as_str());
}
if let Some(var_82) = &input.dashboard_definition {
object.key("dashboardDefinition").string(var_82.as_str());
}
if let Some(var_83) = &input.dashboard_description {
object.key("dashboardDescription").string(var_83.as_str());
}
if let Some(var_84) = &input.dashboard_name {
object.key("dashboardName").string(var_84.as_str());
}
if let Some(var_85) = &input.project_id {
object.key("projectId").string(var_85.as_str());
}
if let Some(var_86) = &input.tags {
#[allow(unused_mut)]
let mut object_87 = object.key("tags").start_object();
for (key_88, value_89) in var_86 {
{
object_87.key(key_88.as_str()).string(value_89.as_str());
}
}
object_87.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_gateway_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateGatewayInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_90) = &input.gateway_name {
object.key("gatewayName").string(var_90.as_str());
}
if let Some(var_91) = &input.gateway_platform {
#[allow(unused_mut)]
let mut object_92 = object.key("gatewayPlatform").start_object();
crate::json_ser::serialize_structure_crate_model_gateway_platform(&mut object_92, var_91)?;
object_92.finish();
}
if let Some(var_93) = &input.tags {
#[allow(unused_mut)]
let mut object_94 = object.key("tags").start_object();
for (key_95, value_96) in var_93 {
{
object_94.key(key_95.as_str()).string(value_96.as_str());
}
}
object_94.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_portal_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreatePortalInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_97) = &input.alarms {
#[allow(unused_mut)]
let mut object_98 = object.key("alarms").start_object();
crate::json_ser::serialize_structure_crate_model_alarms(&mut object_98, var_97)?;
object_98.finish();
}
if let Some(var_99) = &input.client_token {
object.key("clientToken").string(var_99.as_str());
}
if let Some(var_100) = &input.notification_sender_email {
object
.key("notificationSenderEmail")
.string(var_100.as_str());
}
if let Some(var_101) = &input.portal_auth_mode {
object.key("portalAuthMode").string(var_101.as_str());
}
if let Some(var_102) = &input.portal_contact_email {
object.key("portalContactEmail").string(var_102.as_str());
}
if let Some(var_103) = &input.portal_description {
object.key("portalDescription").string(var_103.as_str());
}
if let Some(var_104) = &input.portal_logo_image_file {
#[allow(unused_mut)]
let mut object_105 = object.key("portalLogoImageFile").start_object();
crate::json_ser::serialize_structure_crate_model_image_file(&mut object_105, var_104)?;
object_105.finish();
}
if let Some(var_106) = &input.portal_name {
object.key("portalName").string(var_106.as_str());
}
if let Some(var_107) = &input.role_arn {
object.key("roleArn").string(var_107.as_str());
}
if let Some(var_108) = &input.tags {
#[allow(unused_mut)]
let mut object_109 = object.key("tags").start_object();
for (key_110, value_111) in var_108 {
{
object_109.key(key_110.as_str()).string(value_111.as_str());
}
}
object_109.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_project_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateProjectInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_112) = &input.client_token {
object.key("clientToken").string(var_112.as_str());
}
if let Some(var_113) = &input.portal_id {
object.key("portalId").string(var_113.as_str());
}
if let Some(var_114) = &input.project_description {
object.key("projectDescription").string(var_114.as_str());
}
if let Some(var_115) = &input.project_name {
object.key("projectName").string(var_115.as_str());
}
if let Some(var_116) = &input.tags {
#[allow(unused_mut)]
let mut object_117 = object.key("tags").start_object();
for (key_118, value_119) in var_116 {
{
object_117.key(key_118.as_str()).string(value_119.as_str());
}
}
object_117.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_time_series_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteTimeSeriesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_120) = &input.client_token {
object.key("clientToken").string(var_120.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_assets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateAssetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_121) = &input.child_asset_id {
object.key("childAssetId").string(var_121.as_str());
}
if let Some(var_122) = &input.client_token {
object.key("clientToken").string(var_122.as_str());
}
if let Some(var_123) = &input.hierarchy_id {
object.key("hierarchyId").string(var_123.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_time_series_from_asset_property_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateTimeSeriesFromAssetPropertyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_124) = &input.client_token {
object.key("clientToken").string(var_124.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_default_encryption_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutDefaultEncryptionConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_125) = &input.encryption_type {
object.key("encryptionType").string(var_125.as_str());
}
if let Some(var_126) = &input.kms_key_id {
object.key("kmsKeyId").string(var_126.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_logging_options_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutLoggingOptionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_127) = &input.logging_options {
#[allow(unused_mut)]
let mut object_128 = object.key("loggingOptions").start_object();
crate::json_ser::serialize_structure_crate_model_logging_options(&mut object_128, var_127)?;
object_128.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_storage_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutStorageConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_129) = &input.disassociated_data_storage {
object
.key("disassociatedDataStorage")
.string(var_129.as_str());
}
if let Some(var_130) = &input.multi_layer_storage {
#[allow(unused_mut)]
let mut object_131 = object.key("multiLayerStorage").start_object();
crate::json_ser::serialize_structure_crate_model_multi_layer_storage(
&mut object_131,
var_130,
)?;
object_131.finish();
}
if let Some(var_132) = &input.retention_period {
#[allow(unused_mut)]
let mut object_133 = object.key("retentionPeriod").start_object();
crate::json_ser::serialize_structure_crate_model_retention_period(
&mut object_133,
var_132,
)?;
object_133.finish();
}
if let Some(var_134) = &input.storage_type {
object.key("storageType").string(var_134.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_135) = &input.tags {
#[allow(unused_mut)]
let mut object_136 = object.key("tags").start_object();
for (key_137, value_138) in var_135 {
{
object_136.key(key_137.as_str()).string(value_138.as_str());
}
}
object_136.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_access_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAccessPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_139) = &input.access_policy_identity {
#[allow(unused_mut)]
let mut object_140 = object.key("accessPolicyIdentity").start_object();
crate::json_ser::serialize_structure_crate_model_identity(&mut object_140, var_139)?;
object_140.finish();
}
if let Some(var_141) = &input.access_policy_permission {
object
.key("accessPolicyPermission")
.string(var_141.as_str());
}
if let Some(var_142) = &input.access_policy_resource {
#[allow(unused_mut)]
let mut object_143 = object.key("accessPolicyResource").start_object();
crate::json_ser::serialize_structure_crate_model_resource(&mut object_143, var_142)?;
object_143.finish();
}
if let Some(var_144) = &input.client_token {
object.key("clientToken").string(var_144.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_asset_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAssetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_145) = &input.asset_description {
object.key("assetDescription").string(var_145.as_str());
}
if let Some(var_146) = &input.asset_name {
object.key("assetName").string(var_146.as_str());
}
if let Some(var_147) = &input.client_token {
object.key("clientToken").string(var_147.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_asset_model_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAssetModelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_148) = &input.asset_model_composite_models {
let mut array_149 = object.key("assetModelCompositeModels").start_array();
for item_150 in var_148 {
{
#[allow(unused_mut)]
let mut object_151 = array_149.value().start_object();
crate::json_ser::serialize_structure_crate_model_asset_model_composite_model(
&mut object_151,
item_150,
)?;
object_151.finish();
}
}
array_149.finish();
}
if let Some(var_152) = &input.asset_model_description {
object.key("assetModelDescription").string(var_152.as_str());
}
if let Some(var_153) = &input.asset_model_hierarchies {
let mut array_154 = object.key("assetModelHierarchies").start_array();
for item_155 in var_153 {
{
#[allow(unused_mut)]
let mut object_156 = array_154.value().start_object();
crate::json_ser::serialize_structure_crate_model_asset_model_hierarchy(
&mut object_156,
item_155,
)?;
object_156.finish();
}
}
array_154.finish();
}
if let Some(var_157) = &input.asset_model_name {
object.key("assetModelName").string(var_157.as_str());
}
if let Some(var_158) = &input.asset_model_properties {
let mut array_159 = object.key("assetModelProperties").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_asset_model_property(
&mut object_161,
item_160,
)?;
object_161.finish();
}
}
array_159.finish();
}
if let Some(var_162) = &input.client_token {
object.key("clientToken").string(var_162.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_asset_property_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAssetPropertyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_163) = &input.client_token {
object.key("clientToken").string(var_163.as_str());
}
if let Some(var_164) = &input.property_alias {
object.key("propertyAlias").string(var_164.as_str());
}
if let Some(var_165) = &input.property_notification_state {
object
.key("propertyNotificationState")
.string(var_165.as_str());
}
if let Some(var_166) = &input.property_unit {
object.key("propertyUnit").string(var_166.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_dashboard_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDashboardInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_167) = &input.client_token {
object.key("clientToken").string(var_167.as_str());
}
if let Some(var_168) = &input.dashboard_definition {
object.key("dashboardDefinition").string(var_168.as_str());
}
if let Some(var_169) = &input.dashboard_description {
object.key("dashboardDescription").string(var_169.as_str());
}
if let Some(var_170) = &input.dashboard_name {
object.key("dashboardName").string(var_170.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_gateway_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateGatewayInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_171) = &input.gateway_name {
object.key("gatewayName").string(var_171.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_gateway_capability_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateGatewayCapabilityConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_172) = &input.capability_configuration {
object
.key("capabilityConfiguration")
.string(var_172.as_str());
}
if let Some(var_173) = &input.capability_namespace {
object.key("capabilityNamespace").string(var_173.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_portal_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdatePortalInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_174) = &input.alarms {
#[allow(unused_mut)]
let mut object_175 = object.key("alarms").start_object();
crate::json_ser::serialize_structure_crate_model_alarms(&mut object_175, var_174)?;
object_175.finish();
}
if let Some(var_176) = &input.client_token {
object.key("clientToken").string(var_176.as_str());
}
if let Some(var_177) = &input.notification_sender_email {
object
.key("notificationSenderEmail")
.string(var_177.as_str());
}
if let Some(var_178) = &input.portal_contact_email {
object.key("portalContactEmail").string(var_178.as_str());
}
if let Some(var_179) = &input.portal_description {
object.key("portalDescription").string(var_179.as_str());
}
if let Some(var_180) = &input.portal_logo_image {
#[allow(unused_mut)]
let mut object_181 = object.key("portalLogoImage").start_object();
crate::json_ser::serialize_structure_crate_model_image(&mut object_181, var_180)?;
object_181.finish();
}
if let Some(var_182) = &input.portal_name {
object.key("portalName").string(var_182.as_str());
}
if let Some(var_183) = &input.role_arn {
object.key("roleArn").string(var_183.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_project_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateProjectInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_184) = &input.client_token {
object.key("clientToken").string(var_184.as_str());
}
if let Some(var_185) = &input.project_description {
object.key("projectDescription").string(var_185.as_str());
}
if let Some(var_186) = &input.project_name {
object.key("projectName").string(var_186.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_batch_get_asset_property_aggregates_entry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BatchGetAssetPropertyAggregatesEntry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_187) = &input.entry_id {
object.key("entryId").string(var_187.as_str());
}
if let Some(var_188) = &input.asset_id {
object.key("assetId").string(var_188.as_str());
}
if let Some(var_189) = &input.property_id {
object.key("propertyId").string(var_189.as_str());
}
if let Some(var_190) = &input.property_alias {
object.key("propertyAlias").string(var_190.as_str());
}
if let Some(var_191) = &input.aggregate_types {
let mut array_192 = object.key("aggregateTypes").start_array();
for item_193 in var_191 {
{
array_192.value().string(item_193.as_str());
}
}
array_192.finish();
}
if let Some(var_194) = &input.resolution {
object.key("resolution").string(var_194.as_str());
}
if let Some(var_195) = &input.start_date {
object
.key("startDate")
.date_time(var_195, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_196) = &input.end_date {
object
.key("endDate")
.date_time(var_196, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_197) = &input.qualities {
let mut array_198 = object.key("qualities").start_array();
for item_199 in var_197 {
{
array_198.value().string(item_199.as_str());
}
}
array_198.finish();
}
if let Some(var_200) = &input.time_ordering {
object.key("timeOrdering").string(var_200.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_batch_get_asset_property_value_entry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BatchGetAssetPropertyValueEntry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_201) = &input.entry_id {
object.key("entryId").string(var_201.as_str());
}
if let Some(var_202) = &input.asset_id {
object.key("assetId").string(var_202.as_str());
}
if let Some(var_203) = &input.property_id {
object.key("propertyId").string(var_203.as_str());
}
if let Some(var_204) = &input.property_alias {
object.key("propertyAlias").string(var_204.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_batch_get_asset_property_value_history_entry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BatchGetAssetPropertyValueHistoryEntry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_205) = &input.entry_id {
object.key("entryId").string(var_205.as_str());
}
if let Some(var_206) = &input.asset_id {
object.key("assetId").string(var_206.as_str());
}
if let Some(var_207) = &input.property_id {
object.key("propertyId").string(var_207.as_str());
}
if let Some(var_208) = &input.property_alias {
object.key("propertyAlias").string(var_208.as_str());
}
if let Some(var_209) = &input.start_date {
object
.key("startDate")
.date_time(var_209, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_210) = &input.end_date {
object
.key("endDate")
.date_time(var_210, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_211) = &input.qualities {
let mut array_212 = object.key("qualities").start_array();
for item_213 in var_211 {
{
array_212.value().string(item_213.as_str());
}
}
array_212.finish();
}
if let Some(var_214) = &input.time_ordering {
object.key("timeOrdering").string(var_214.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_put_asset_property_value_entry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PutAssetPropertyValueEntry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_215) = &input.entry_id {
object.key("entryId").string(var_215.as_str());
}
if let Some(var_216) = &input.asset_id {
object.key("assetId").string(var_216.as_str());
}
if let Some(var_217) = &input.property_id {
object.key("propertyId").string(var_217.as_str());
}
if let Some(var_218) = &input.property_alias {
object.key("propertyAlias").string(var_218.as_str());
}
if let Some(var_219) = &input.property_values {
let mut array_220 = object.key("propertyValues").start_array();
for item_221 in var_219 {
{
#[allow(unused_mut)]
let mut object_222 = array_220.value().start_object();
crate::json_ser::serialize_structure_crate_model_asset_property_value(
&mut object_222,
item_221,
)?;
object_222.finish();
}
}
array_220.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_identity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Identity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_223) = &input.user {
#[allow(unused_mut)]
let mut object_224 = object.key("user").start_object();
crate::json_ser::serialize_structure_crate_model_user_identity(&mut object_224, var_223)?;
object_224.finish();
}
if let Some(var_225) = &input.group {
#[allow(unused_mut)]
let mut object_226 = object.key("group").start_object();
crate::json_ser::serialize_structure_crate_model_group_identity(&mut object_226, var_225)?;
object_226.finish();
}
if let Some(var_227) = &input.iam_user {
#[allow(unused_mut)]
let mut object_228 = object.key("iamUser").start_object();
crate::json_ser::serialize_structure_crate_model_iam_user_identity(
&mut object_228,
var_227,
)?;
object_228.finish();
}
if let Some(var_229) = &input.iam_role {
#[allow(unused_mut)]
let mut object_230 = object.key("iamRole").start_object();
crate::json_ser::serialize_structure_crate_model_iam_role_identity(
&mut object_230,
var_229,
)?;
object_230.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_231) = &input.portal {
#[allow(unused_mut)]
let mut object_232 = object.key("portal").start_object();
crate::json_ser::serialize_structure_crate_model_portal_resource(&mut object_232, var_231)?;
object_232.finish();
}
if let Some(var_233) = &input.project {
#[allow(unused_mut)]
let mut object_234 = object.key("project").start_object();
crate::json_ser::serialize_structure_crate_model_project_resource(
&mut object_234,
var_233,
)?;
object_234.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_asset_model_composite_model_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AssetModelCompositeModelDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_235) = &input.name {
object.key("name").string(var_235.as_str());
}
if let Some(var_236) = &input.description {
object.key("description").string(var_236.as_str());
}
if let Some(var_237) = &input.r#type {
object.key("type").string(var_237.as_str());
}
if let Some(var_238) = &input.properties {
let mut array_239 = object.key("properties").start_array();
for item_240 in var_238 {
{
#[allow(unused_mut)]
let mut object_241 = array_239.value().start_object();
crate::json_ser::serialize_structure_crate_model_asset_model_property_definition(
&mut object_241,
item_240,
)?;
object_241.finish();
}
}
array_239.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_asset_model_hierarchy_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AssetModelHierarchyDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_242) = &input.name {
object.key("name").string(var_242.as_str());
}
if let Some(var_243) = &input.child_asset_model_id {
object.key("childAssetModelId").string(var_243.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_asset_model_property_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AssetModelPropertyDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_244) = &input.name {
object.key("name").string(var_244.as_str());
}
if let Some(var_245) = &input.data_type {
object.key("dataType").string(var_245.as_str());
}
if let Some(var_246) = &input.data_type_spec {
object.key("dataTypeSpec").string(var_246.as_str());
}
if let Some(var_247) = &input.unit {
object.key("unit").string(var_247.as_str());
}
if let Some(var_248) = &input.r#type {
#[allow(unused_mut)]
let mut object_249 = object.key("type").start_object();
crate::json_ser::serialize_structure_crate_model_property_type(&mut object_249, var_248)?;
object_249.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_error_report_location(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ErrorReportLocation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_250) = &input.bucket {
object.key("bucket").string(var_250.as_str());
}
if let Some(var_251) = &input.prefix {
object.key("prefix").string(var_251.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_file(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::File,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_252) = &input.bucket {
object.key("bucket").string(var_252.as_str());
}
if let Some(var_253) = &input.key {
object.key("key").string(var_253.as_str());
}
if let Some(var_254) = &input.version_id {
object.key("versionId").string(var_254.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_job_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JobConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_255) = &input.file_format {
#[allow(unused_mut)]
let mut object_256 = object.key("fileFormat").start_object();
crate::json_ser::serialize_structure_crate_model_file_format(&mut object_256, var_255)?;
object_256.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_gateway_platform(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GatewayPlatform,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_257) = &input.greengrass {
#[allow(unused_mut)]
let mut object_258 = object.key("greengrass").start_object();
crate::json_ser::serialize_structure_crate_model_greengrass(&mut object_258, var_257)?;
object_258.finish();
}
if let Some(var_259) = &input.greengrass_v2 {
#[allow(unused_mut)]
let mut object_260 = object.key("greengrassV2").start_object();
crate::json_ser::serialize_structure_crate_model_greengrass_v2(&mut object_260, var_259)?;
object_260.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_alarms(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Alarms,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_261) = &input.alarm_role_arn {
object.key("alarmRoleArn").string(var_261.as_str());
}
if let Some(var_262) = &input.notification_lambda_arn {
object.key("notificationLambdaArn").string(var_262.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_image_file(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ImageFile,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_263) = &input.data {
object
.key("data")
.string_unchecked(&aws_smithy_types::base64::encode(var_263));
}
if let Some(var_264) = &input.r#type {
object.key("type").string(var_264.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_logging_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoggingOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_265) = &input.level {
object.key("level").string(var_265.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_multi_layer_storage(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MultiLayerStorage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_266) = &input.customer_managed_s3_storage {
#[allow(unused_mut)]
let mut object_267 = object.key("customerManagedS3Storage").start_object();
crate::json_ser::serialize_structure_crate_model_customer_managed_s3_storage(
&mut object_267,
var_266,
)?;
object_267.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_retention_period(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RetentionPeriod,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_268) = &input.number_of_days {
object.key("numberOfDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_268).into()),
);
}
if let Some(var_269) = &input.unlimited {
object.key("unlimited").boolean(*var_269);
}
Ok(())
}
pub fn serialize_structure_crate_model_asset_model_composite_model(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AssetModelCompositeModel,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_270) = &input.name {
object.key("name").string(var_270.as_str());
}
if let Some(var_271) = &input.description {
object.key("description").string(var_271.as_str());
}
if let Some(var_272) = &input.r#type {
object.key("type").string(var_272.as_str());
}
if let Some(var_273) = &input.properties {
let mut array_274 = object.key("properties").start_array();
for item_275 in var_273 {
{
#[allow(unused_mut)]
let mut object_276 = array_274.value().start_object();
crate::json_ser::serialize_structure_crate_model_asset_model_property(
&mut object_276,
item_275,
)?;
object_276.finish();
}
}
array_274.finish();
}
if let Some(var_277) = &input.id {
object.key("id").string(var_277.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_asset_model_hierarchy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AssetModelHierarchy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_278) = &input.id {
object.key("id").string(var_278.as_str());
}
if let Some(var_279) = &input.name {
object.key("name").string(var_279.as_str());
}
if let Some(var_280) = &input.child_asset_model_id {
object.key("childAssetModelId").string(var_280.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_asset_model_property(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AssetModelProperty,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_281) = &input.id {
object.key("id").string(var_281.as_str());
}
if let Some(var_282) = &input.name {
object.key("name").string(var_282.as_str());
}
if let Some(var_283) = &input.data_type {
object.key("dataType").string(var_283.as_str());
}
if let Some(var_284) = &input.data_type_spec {
object.key("dataTypeSpec").string(var_284.as_str());
}
if let Some(var_285) = &input.unit {
object.key("unit").string(var_285.as_str());
}
if let Some(var_286) = &input.r#type {
#[allow(unused_mut)]
let mut object_287 = object.key("type").start_object();
crate::json_ser::serialize_structure_crate_model_property_type(&mut object_287, var_286)?;
object_287.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_image(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Image,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_288) = &input.id {
object.key("id").string(var_288.as_str());
}
if let Some(var_289) = &input.file {
#[allow(unused_mut)]
let mut object_290 = object.key("file").start_object();
crate::json_ser::serialize_structure_crate_model_image_file(&mut object_290, var_289)?;
object_290.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_asset_property_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AssetPropertyValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_291) = &input.value {
#[allow(unused_mut)]
let mut object_292 = object.key("value").start_object();
crate::json_ser::serialize_structure_crate_model_variant(&mut object_292, var_291)?;
object_292.finish();
}
if let Some(var_293) = &input.timestamp {
#[allow(unused_mut)]
let mut object_294 = object.key("timestamp").start_object();
crate::json_ser::serialize_structure_crate_model_time_in_nanos(&mut object_294, var_293)?;
object_294.finish();
}
if let Some(var_295) = &input.quality {
object.key("quality").string(var_295.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_user_identity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UserIdentity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_296) = &input.id {
object.key("id").string(var_296.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_group_identity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GroupIdentity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_297) = &input.id {
object.key("id").string(var_297.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_iam_user_identity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IamUserIdentity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_298) = &input.arn {
object.key("arn").string(var_298.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_iam_role_identity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IamRoleIdentity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_299) = &input.arn {
object.key("arn").string(var_299.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_portal_resource(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PortalResource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_300) = &input.id {
object.key("id").string(var_300.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_project_resource(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProjectResource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_301) = &input.id {
object.key("id").string(var_301.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_property_type(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PropertyType,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_302) = &input.attribute {
#[allow(unused_mut)]
let mut object_303 = object.key("attribute").start_object();
crate::json_ser::serialize_structure_crate_model_attribute(&mut object_303, var_302)?;
object_303.finish();
}
if let Some(var_304) = &input.measurement {
#[allow(unused_mut)]
let mut object_305 = object.key("measurement").start_object();
crate::json_ser::serialize_structure_crate_model_measurement(&mut object_305, var_304)?;
object_305.finish();
}
if let Some(var_306) = &input.transform {
#[allow(unused_mut)]
let mut object_307 = object.key("transform").start_object();
crate::json_ser::serialize_structure_crate_model_transform(&mut object_307, var_306)?;
object_307.finish();
}
if let Some(var_308) = &input.metric {
#[allow(unused_mut)]
let mut object_309 = object.key("metric").start_object();
crate::json_ser::serialize_structure_crate_model_metric(&mut object_309, var_308)?;
object_309.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_file_format(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FileFormat,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_310) = &input.csv {
#[allow(unused_mut)]
let mut object_311 = object.key("csv").start_object();
crate::json_ser::serialize_structure_crate_model_csv(&mut object_311, var_310)?;
object_311.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_greengrass(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Greengrass,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_312) = &input.group_arn {
object.key("groupArn").string(var_312.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_greengrass_v2(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GreengrassV2,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_313) = &input.core_device_thing_name {
object.key("coreDeviceThingName").string(var_313.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_customer_managed_s3_storage(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomerManagedS3Storage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_314) = &input.s3_resource_arn {
object.key("s3ResourceArn").string(var_314.as_str());
}
if let Some(var_315) = &input.role_arn {
object.key("roleArn").string(var_315.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_variant(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Variant,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_316) = &input.string_value {
object.key("stringValue").string(var_316.as_str());
}
if let Some(var_317) = &input.integer_value {
object.key("integerValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_317).into()),
);
}
if let Some(var_318) = &input.double_value {
object.key("doubleValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_318).into()),
);
}
if let Some(var_319) = &input.boolean_value {
object.key("booleanValue").boolean(*var_319);
}
Ok(())
}
pub fn serialize_structure_crate_model_time_in_nanos(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimeInNanos,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_320) = &input.time_in_seconds {
object.key("timeInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_320).into()),
);
}
if let Some(var_321) = &input.offset_in_nanos {
object.key("offsetInNanos").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_321).into()),
);
}
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_322) = &input.default_value {
object.key("defaultValue").string(var_322.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_measurement(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Measurement,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_323) = &input.processing_config {
#[allow(unused_mut)]
let mut object_324 = object.key("processingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_measurement_processing_config(
&mut object_324,
var_323,
)?;
object_324.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_transform(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Transform,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_325) = &input.expression {
object.key("expression").string(var_325.as_str());
}
if let Some(var_326) = &input.variables {
let mut array_327 = object.key("variables").start_array();
for item_328 in var_326 {
{
#[allow(unused_mut)]
let mut object_329 = array_327.value().start_object();
crate::json_ser::serialize_structure_crate_model_expression_variable(
&mut object_329,
item_328,
)?;
object_329.finish();
}
}
array_327.finish();
}
if let Some(var_330) = &input.processing_config {
#[allow(unused_mut)]
let mut object_331 = object.key("processingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_transform_processing_config(
&mut object_331,
var_330,
)?;
object_331.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_metric(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Metric,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_332) = &input.expression {
object.key("expression").string(var_332.as_str());
}
if let Some(var_333) = &input.variables {
let mut array_334 = object.key("variables").start_array();
for item_335 in var_333 {
{
#[allow(unused_mut)]
let mut object_336 = array_334.value().start_object();
crate::json_ser::serialize_structure_crate_model_expression_variable(
&mut object_336,
item_335,
)?;
object_336.finish();
}
}
array_334.finish();
}
if let Some(var_337) = &input.window {
#[allow(unused_mut)]
let mut object_338 = object.key("window").start_object();
crate::json_ser::serialize_structure_crate_model_metric_window(&mut object_338, var_337)?;
object_338.finish();
}
if let Some(var_339) = &input.processing_config {
#[allow(unused_mut)]
let mut object_340 = object.key("processingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_metric_processing_config(
&mut object_340,
var_339,
)?;
object_340.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_csv(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Csv,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_341) = &input.column_names {
let mut array_342 = object.key("columnNames").start_array();
for item_343 in var_341 {
{
array_342.value().string(item_343.as_str());
}
}
array_342.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_measurement_processing_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MeasurementProcessingConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_344) = &input.forwarding_config {
#[allow(unused_mut)]
let mut object_345 = object.key("forwardingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_forwarding_config(
&mut object_345,
var_344,
)?;
object_345.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_expression_variable(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExpressionVariable,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_346) = &input.name {
object.key("name").string(var_346.as_str());
}
if let Some(var_347) = &input.value {
#[allow(unused_mut)]
let mut object_348 = object.key("value").start_object();
crate::json_ser::serialize_structure_crate_model_variable_value(&mut object_348, var_347)?;
object_348.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_transform_processing_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TransformProcessingConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_349) = &input.compute_location {
object.key("computeLocation").string(var_349.as_str());
}
if let Some(var_350) = &input.forwarding_config {
#[allow(unused_mut)]
let mut object_351 = object.key("forwardingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_forwarding_config(
&mut object_351,
var_350,
)?;
object_351.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_metric_window(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MetricWindow,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_352) = &input.tumbling {
#[allow(unused_mut)]
let mut object_353 = object.key("tumbling").start_object();
crate::json_ser::serialize_structure_crate_model_tumbling_window(&mut object_353, var_352)?;
object_353.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_metric_processing_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MetricProcessingConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_354) = &input.compute_location {
object.key("computeLocation").string(var_354.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_forwarding_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ForwardingConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_355) = &input.state {
object.key("state").string(var_355.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_variable_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VariableValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_356) = &input.property_id {
object.key("propertyId").string(var_356.as_str());
}
if let Some(var_357) = &input.hierarchy_id {
object.key("hierarchyId").string(var_357.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tumbling_window(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TumblingWindow,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_358) = &input.interval {
object.key("interval").string(var_358.as_str());
}
if let Some(var_359) = &input.offset {
object.key("offset").string(var_359.as_str());
}
Ok(())
}