pub fn serialize_structure_crate_input_batch_put_property_values_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchPutPropertyValuesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.entries {
let mut array_2 = object.key("entries").start_array();
for item_3 in var_1 {
{
#[allow(unused_mut)]
let mut object_4 = array_2.value().start_object();
crate::json_ser::serialize_structure_crate_model_property_value_entry(
&mut object_4,
item_3,
)?;
object_4.finish();
}
}
array_2.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_component_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateComponentTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_5) = &input.component_type_name {
object.key("componentTypeName").string(var_5.as_str());
}
if let Some(var_6) = &input.description {
object.key("description").string(var_6.as_str());
}
if let Some(var_7) = &input.extends_from {
let mut array_8 = object.key("extendsFrom").start_array();
for item_9 in var_7 {
{
array_8.value().string(item_9.as_str());
}
}
array_8.finish();
}
if let Some(var_10) = &input.functions {
#[allow(unused_mut)]
let mut object_11 = object.key("functions").start_object();
for (key_12, value_13) in var_10 {
{
#[allow(unused_mut)]
let mut object_14 = object_11.key(key_12.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_function_request(
&mut object_14,
value_13,
)?;
object_14.finish();
}
}
object_11.finish();
}
if let Some(var_15) = &input.is_singleton {
object.key("isSingleton").boolean(*var_15);
}
if let Some(var_16) = &input.property_definitions {
#[allow(unused_mut)]
let mut object_17 = object.key("propertyDefinitions").start_object();
for (key_18, value_19) in var_16 {
{
#[allow(unused_mut)]
let mut object_20 = object_17.key(key_18.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_property_definition_request(
&mut object_20,
value_19,
)?;
object_20.finish();
}
}
object_17.finish();
}
if let Some(var_21) = &input.property_groups {
#[allow(unused_mut)]
let mut object_22 = object.key("propertyGroups").start_object();
for (key_23, value_24) in var_21 {
{
#[allow(unused_mut)]
let mut object_25 = object_22.key(key_23.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_property_group_request(
&mut object_25,
value_24,
)?;
object_25.finish();
}
}
object_22.finish();
}
if let Some(var_26) = &input.tags {
#[allow(unused_mut)]
let mut object_27 = object.key("tags").start_object();
for (key_28, value_29) in var_26 {
{
object_27.key(key_28.as_str()).string(value_29.as_str());
}
}
object_27.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_entity_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateEntityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_30) = &input.components {
#[allow(unused_mut)]
let mut object_31 = object.key("components").start_object();
for (key_32, value_33) in var_30 {
{
#[allow(unused_mut)]
let mut object_34 = object_31.key(key_32.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_component_request(
&mut object_34,
value_33,
)?;
object_34.finish();
}
}
object_31.finish();
}
if let Some(var_35) = &input.description {
object.key("description").string(var_35.as_str());
}
if let Some(var_36) = &input.entity_id {
object.key("entityId").string(var_36.as_str());
}
if let Some(var_37) = &input.entity_name {
object.key("entityName").string(var_37.as_str());
}
if let Some(var_38) = &input.parent_entity_id {
object.key("parentEntityId").string(var_38.as_str());
}
if let Some(var_39) = &input.tags {
#[allow(unused_mut)]
let mut object_40 = object.key("tags").start_object();
for (key_41, value_42) in var_39 {
{
object_40.key(key_41.as_str()).string(value_42.as_str());
}
}
object_40.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_scene_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSceneInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_43) = &input.capabilities {
let mut array_44 = object.key("capabilities").start_array();
for item_45 in var_43 {
{
array_44.value().string(item_45.as_str());
}
}
array_44.finish();
}
if let Some(var_46) = &input.content_location {
object.key("contentLocation").string(var_46.as_str());
}
if let Some(var_47) = &input.description {
object.key("description").string(var_47.as_str());
}
if let Some(var_48) = &input.scene_id {
object.key("sceneId").string(var_48.as_str());
}
if let Some(var_49) = &input.tags {
#[allow(unused_mut)]
let mut object_50 = object.key("tags").start_object();
for (key_51, value_52) in var_49 {
{
object_50.key(key_51.as_str()).string(value_52.as_str());
}
}
object_50.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_sync_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSyncJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_53) = &input.sync_role {
object.key("syncRole").string(var_53.as_str());
}
if let Some(var_54) = &input.tags {
#[allow(unused_mut)]
let mut object_55 = object.key("tags").start_object();
for (key_56, value_57) in var_54 {
{
object_55.key(key_56.as_str()).string(value_57.as_str());
}
}
object_55.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_workspace_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateWorkspaceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_58) = &input.description {
object.key("description").string(var_58.as_str());
}
if let Some(var_59) = &input.role {
object.key("role").string(var_59.as_str());
}
if let Some(var_60) = &input.s3_location {
object.key("s3Location").string(var_60.as_str());
}
if let Some(var_61) = &input.tags {
#[allow(unused_mut)]
let mut object_62 = object.key("tags").start_object();
for (key_63, value_64) in var_61 {
{
object_62.key(key_63.as_str()).string(value_64.as_str());
}
}
object_62.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_execute_query_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ExecuteQueryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_65) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_65).into()),
);
}
if let Some(var_66) = &input.next_token {
object.key("nextToken").string(var_66.as_str());
}
if let Some(var_67) = &input.query_statement {
object.key("queryStatement").string(var_67.as_str());
}
if let Some(var_68) = &input.workspace_id {
object.key("workspaceId").string(var_68.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_property_value_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetPropertyValueInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_69) = &input.component_name {
object.key("componentName").string(var_69.as_str());
}
if let Some(var_70) = &input.component_type_id {
object.key("componentTypeId").string(var_70.as_str());
}
if let Some(var_71) = &input.entity_id {
object.key("entityId").string(var_71.as_str());
}
if let Some(var_72) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_72).into()),
);
}
if let Some(var_73) = &input.next_token {
object.key("nextToken").string(var_73.as_str());
}
if let Some(var_74) = &input.property_group_name {
object.key("propertyGroupName").string(var_74.as_str());
}
if let Some(var_75) = &input.selected_properties {
let mut array_76 = object.key("selectedProperties").start_array();
for item_77 in var_75 {
{
array_76.value().string(item_77.as_str());
}
}
array_76.finish();
}
if let Some(var_78) = &input.tabular_conditions {
#[allow(unused_mut)]
let mut object_79 = object.key("tabularConditions").start_object();
crate::json_ser::serialize_structure_crate_model_tabular_conditions(
&mut object_79,
var_78,
)?;
object_79.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_property_value_history_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetPropertyValueHistoryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_80) = &input.component_name {
object.key("componentName").string(var_80.as_str());
}
if let Some(var_81) = &input.component_type_id {
object.key("componentTypeId").string(var_81.as_str());
}
if let Some(var_82) = &input.end_date_time {
object
.key("endDateTime")
.date_time(var_82, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_83) = &input.end_time {
object.key("endTime").string(var_83.as_str());
}
if let Some(var_84) = &input.entity_id {
object.key("entityId").string(var_84.as_str());
}
if let Some(var_85) = &input.interpolation {
#[allow(unused_mut)]
let mut object_86 = object.key("interpolation").start_object();
crate::json_ser::serialize_structure_crate_model_interpolation_parameters(
&mut object_86,
var_85,
)?;
object_86.finish();
}
if let Some(var_87) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_87).into()),
);
}
if let Some(var_88) = &input.next_token {
object.key("nextToken").string(var_88.as_str());
}
if let Some(var_89) = &input.order_by_time {
object.key("orderByTime").string(var_89.as_str());
}
if let Some(var_90) = &input.property_filters {
let mut array_91 = object.key("propertyFilters").start_array();
for item_92 in var_90 {
{
#[allow(unused_mut)]
let mut object_93 = array_91.value().start_object();
crate::json_ser::serialize_structure_crate_model_property_filter(
&mut object_93,
item_92,
)?;
object_93.finish();
}
}
array_91.finish();
}
if let Some(var_94) = &input.selected_properties {
let mut array_95 = object.key("selectedProperties").start_array();
for item_96 in var_94 {
{
array_95.value().string(item_96.as_str());
}
}
array_95.finish();
}
if let Some(var_97) = &input.start_date_time {
object
.key("startDateTime")
.date_time(var_97, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_98) = &input.start_time {
object.key("startTime").string(var_98.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_component_types_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListComponentTypesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_99) = &input.filters {
let mut array_100 = object.key("filters").start_array();
for item_101 in var_99 {
{
#[allow(unused_mut)]
let mut object_102 = array_100.value().start_object();
crate::json_ser::serialize_union_crate_model_list_component_types_filter(
&mut object_102,
item_101,
)?;
object_102.finish();
}
}
array_100.finish();
}
if let Some(var_103) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_103).into()),
);
}
if let Some(var_104) = &input.next_token {
object.key("nextToken").string(var_104.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_entities_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListEntitiesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_105) = &input.filters {
let mut array_106 = object.key("filters").start_array();
for item_107 in var_105 {
{
#[allow(unused_mut)]
let mut object_108 = array_106.value().start_object();
crate::json_ser::serialize_union_crate_model_list_entities_filter(
&mut object_108,
item_107,
)?;
object_108.finish();
}
}
array_106.finish();
}
if let Some(var_109) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_109).into()),
);
}
if let Some(var_110) = &input.next_token {
object.key("nextToken").string(var_110.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_scenes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListScenesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_111) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_111).into()),
);
}
if let Some(var_112) = &input.next_token {
object.key("nextToken").string(var_112.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_sync_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSyncJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_113) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_113).into()),
);
}
if let Some(var_114) = &input.next_token {
object.key("nextToken").string(var_114.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_sync_resources_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSyncResourcesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_115) = &input.filters {
let mut array_116 = object.key("filters").start_array();
for item_117 in var_115 {
{
#[allow(unused_mut)]
let mut object_118 = array_116.value().start_object();
crate::json_ser::serialize_union_crate_model_sync_resource_filter(
&mut object_118,
item_117,
)?;
object_118.finish();
}
}
array_116.finish();
}
if let Some(var_119) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_119).into()),
);
}
if let Some(var_120) = &input.next_token {
object.key("nextToken").string(var_120.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tags_for_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTagsForResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_121) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_121).into()),
);
}
if let Some(var_122) = &input.next_token {
object.key("nextToken").string(var_122.as_str());
}
if let Some(var_123) = &input.resource_arn {
object.key("resourceARN").string(var_123.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_workspaces_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListWorkspacesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_124) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_124).into()),
);
}
if let Some(var_125) = &input.next_token {
object.key("nextToken").string(var_125.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_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_126) = &input.resource_arn {
object.key("resourceARN").string(var_126.as_str());
}
if let Some(var_127) = &input.tags {
#[allow(unused_mut)]
let mut object_128 = object.key("tags").start_object();
for (key_129, value_130) in var_127 {
{
object_128.key(key_129.as_str()).string(value_130.as_str());
}
}
object_128.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_component_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateComponentTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_131) = &input.component_type_name {
object.key("componentTypeName").string(var_131.as_str());
}
if let Some(var_132) = &input.description {
object.key("description").string(var_132.as_str());
}
if let Some(var_133) = &input.extends_from {
let mut array_134 = object.key("extendsFrom").start_array();
for item_135 in var_133 {
{
array_134.value().string(item_135.as_str());
}
}
array_134.finish();
}
if let Some(var_136) = &input.functions {
#[allow(unused_mut)]
let mut object_137 = object.key("functions").start_object();
for (key_138, value_139) in var_136 {
{
#[allow(unused_mut)]
let mut object_140 = object_137.key(key_138.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_function_request(
&mut object_140,
value_139,
)?;
object_140.finish();
}
}
object_137.finish();
}
if let Some(var_141) = &input.is_singleton {
object.key("isSingleton").boolean(*var_141);
}
if let Some(var_142) = &input.property_definitions {
#[allow(unused_mut)]
let mut object_143 = object.key("propertyDefinitions").start_object();
for (key_144, value_145) in var_142 {
{
#[allow(unused_mut)]
let mut object_146 = object_143.key(key_144.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_property_definition_request(
&mut object_146,
value_145,
)?;
object_146.finish();
}
}
object_143.finish();
}
if let Some(var_147) = &input.property_groups {
#[allow(unused_mut)]
let mut object_148 = object.key("propertyGroups").start_object();
for (key_149, value_150) in var_147 {
{
#[allow(unused_mut)]
let mut object_151 = object_148.key(key_149.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_property_group_request(
&mut object_151,
value_150,
)?;
object_151.finish();
}
}
object_148.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_entity_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateEntityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_152) = &input.component_updates {
#[allow(unused_mut)]
let mut object_153 = object.key("componentUpdates").start_object();
for (key_154, value_155) in var_152 {
{
#[allow(unused_mut)]
let mut object_156 = object_153.key(key_154.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_component_update_request(
&mut object_156,
value_155,
)?;
object_156.finish();
}
}
object_153.finish();
}
if let Some(var_157) = &input.description {
object.key("description").string(var_157.as_str());
}
if let Some(var_158) = &input.entity_name {
object.key("entityName").string(var_158.as_str());
}
if let Some(var_159) = &input.parent_entity_update {
#[allow(unused_mut)]
let mut object_160 = object.key("parentEntityUpdate").start_object();
crate::json_ser::serialize_structure_crate_model_parent_entity_update_request(
&mut object_160,
var_159,
)?;
object_160.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_pricing_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdatePricingPlanInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_161) = &input.bundle_names {
let mut array_162 = object.key("bundleNames").start_array();
for item_163 in var_161 {
{
array_162.value().string(item_163.as_str());
}
}
array_162.finish();
}
if let Some(var_164) = &input.pricing_mode {
object.key("pricingMode").string(var_164.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_scene_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSceneInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_165) = &input.capabilities {
let mut array_166 = object.key("capabilities").start_array();
for item_167 in var_165 {
{
array_166.value().string(item_167.as_str());
}
}
array_166.finish();
}
if let Some(var_168) = &input.content_location {
object.key("contentLocation").string(var_168.as_str());
}
if let Some(var_169) = &input.description {
object.key("description").string(var_169.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_workspace_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateWorkspaceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_170) = &input.description {
object.key("description").string(var_170.as_str());
}
if let Some(var_171) = &input.role {
object.key("role").string(var_171.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_property_value_entry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PropertyValueEntry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_172) = &input.entity_property_reference {
#[allow(unused_mut)]
let mut object_173 = object.key("entityPropertyReference").start_object();
crate::json_ser::serialize_structure_crate_model_entity_property_reference(
&mut object_173,
var_172,
)?;
object_173.finish();
}
if let Some(var_174) = &input.property_values {
let mut array_175 = object.key("propertyValues").start_array();
for item_176 in var_174 {
{
#[allow(unused_mut)]
let mut object_177 = array_175.value().start_object();
crate::json_ser::serialize_structure_crate_model_property_value(
&mut object_177,
item_176,
)?;
object_177.finish();
}
}
array_175.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_function_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FunctionRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_178) = &input.required_properties {
let mut array_179 = object.key("requiredProperties").start_array();
for item_180 in var_178 {
{
array_179.value().string(item_180.as_str());
}
}
array_179.finish();
}
if let Some(var_181) = &input.scope {
object.key("scope").string(var_181.as_str());
}
if let Some(var_182) = &input.implemented_by {
#[allow(unused_mut)]
let mut object_183 = object.key("implementedBy").start_object();
crate::json_ser::serialize_structure_crate_model_data_connector(&mut object_183, var_182)?;
object_183.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_property_definition_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PropertyDefinitionRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_184) = &input.data_type {
#[allow(unused_mut)]
let mut object_185 = object.key("dataType").start_object();
crate::json_ser::serialize_structure_crate_model_data_type(&mut object_185, var_184)?;
object_185.finish();
}
if let Some(var_186) = &input.is_required_in_entity {
object.key("isRequiredInEntity").boolean(*var_186);
}
if let Some(var_187) = &input.is_external_id {
object.key("isExternalId").boolean(*var_187);
}
if let Some(var_188) = &input.is_stored_externally {
object.key("isStoredExternally").boolean(*var_188);
}
if let Some(var_189) = &input.is_time_series {
object.key("isTimeSeries").boolean(*var_189);
}
if let Some(var_190) = &input.default_value {
#[allow(unused_mut)]
let mut object_191 = object.key("defaultValue").start_object();
crate::json_ser::serialize_structure_crate_model_data_value(&mut object_191, var_190)?;
object_191.finish();
}
if let Some(var_192) = &input.configuration {
#[allow(unused_mut)]
let mut object_193 = object.key("configuration").start_object();
for (key_194, value_195) in var_192 {
{
object_193.key(key_194.as_str()).string(value_195.as_str());
}
}
object_193.finish();
}
if let Some(var_196) = &input.display_name {
object.key("displayName").string(var_196.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_property_group_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PropertyGroupRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_197) = &input.group_type {
object.key("groupType").string(var_197.as_str());
}
if let Some(var_198) = &input.property_names {
let mut array_199 = object.key("propertyNames").start_array();
for item_200 in var_198 {
{
array_199.value().string(item_200.as_str());
}
}
array_199.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_component_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComponentRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_201) = &input.description {
object.key("description").string(var_201.as_str());
}
if let Some(var_202) = &input.component_type_id {
object.key("componentTypeId").string(var_202.as_str());
}
if let Some(var_203) = &input.properties {
#[allow(unused_mut)]
let mut object_204 = object.key("properties").start_object();
for (key_205, value_206) in var_203 {
{
#[allow(unused_mut)]
let mut object_207 = object_204.key(key_205.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_property_request(
&mut object_207,
value_206,
)?;
object_207.finish();
}
}
object_204.finish();
}
if let Some(var_208) = &input.property_groups {
#[allow(unused_mut)]
let mut object_209 = object.key("propertyGroups").start_object();
for (key_210, value_211) in var_208 {
{
#[allow(unused_mut)]
let mut object_212 = object_209.key(key_210.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_component_property_group_request(
&mut object_212,
value_211,
)?;
object_212.finish();
}
}
object_209.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tabular_conditions(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TabularConditions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_213) = &input.order_by {
let mut array_214 = object.key("orderBy").start_array();
for item_215 in var_213 {
{
#[allow(unused_mut)]
let mut object_216 = array_214.value().start_object();
crate::json_ser::serialize_structure_crate_model_order_by(
&mut object_216,
item_215,
)?;
object_216.finish();
}
}
array_214.finish();
}
if let Some(var_217) = &input.property_filters {
let mut array_218 = object.key("propertyFilters").start_array();
for item_219 in var_217 {
{
#[allow(unused_mut)]
let mut object_220 = array_218.value().start_object();
crate::json_ser::serialize_structure_crate_model_property_filter(
&mut object_220,
item_219,
)?;
object_220.finish();
}
}
array_218.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_interpolation_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InterpolationParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_221) = &input.interpolation_type {
object.key("interpolationType").string(var_221.as_str());
}
if let Some(var_222) = &input.interval_in_seconds {
object.key("intervalInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_222).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_property_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PropertyFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_223) = &input.property_name {
object.key("propertyName").string(var_223.as_str());
}
if let Some(var_224) = &input.operator {
object.key("operator").string(var_224.as_str());
}
if let Some(var_225) = &input.value {
#[allow(unused_mut)]
let mut object_226 = object.key("value").start_object();
crate::json_ser::serialize_structure_crate_model_data_value(&mut object_226, var_225)?;
object_226.finish();
}
Ok(())
}
pub fn serialize_union_crate_model_list_component_types_filter(
object_102: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListComponentTypesFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::ListComponentTypesFilter::ExtendsFrom(inner) => {
object_102.key("extendsFrom").string(inner.as_str());
}
crate::model::ListComponentTypesFilter::Namespace(inner) => {
object_102.key("namespace").string(inner.as_str());
}
crate::model::ListComponentTypesFilter::IsAbstract(inner) => {
object_102.key("isAbstract").boolean(*inner);
}
crate::model::ListComponentTypesFilter::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"ListComponentTypesFilter",
),
)
}
}
Ok(())
}
pub fn serialize_union_crate_model_list_entities_filter(
object_108: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListEntitiesFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::ListEntitiesFilter::ParentEntityId(inner) => {
object_108.key("parentEntityId").string(inner.as_str());
}
crate::model::ListEntitiesFilter::ComponentTypeId(inner) => {
object_108.key("componentTypeId").string(inner.as_str());
}
crate::model::ListEntitiesFilter::ExternalId(inner) => {
object_108.key("externalId").string(inner.as_str());
}
crate::model::ListEntitiesFilter::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"ListEntitiesFilter",
),
)
}
}
Ok(())
}
pub fn serialize_union_crate_model_sync_resource_filter(
object_118: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SyncResourceFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::SyncResourceFilter::State(inner) => {
object_118.key("state").string(inner.as_str());
}
crate::model::SyncResourceFilter::ResourceType(inner) => {
object_118.key("resourceType").string(inner.as_str());
}
crate::model::SyncResourceFilter::ResourceId(inner) => {
object_118.key("resourceId").string(inner.as_str());
}
crate::model::SyncResourceFilter::ExternalId(inner) => {
object_118.key("externalId").string(inner.as_str());
}
crate::model::SyncResourceFilter::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"SyncResourceFilter",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_component_update_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComponentUpdateRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_227) = &input.update_type {
object.key("updateType").string(var_227.as_str());
}
if let Some(var_228) = &input.description {
object.key("description").string(var_228.as_str());
}
if let Some(var_229) = &input.component_type_id {
object.key("componentTypeId").string(var_229.as_str());
}
if let Some(var_230) = &input.property_updates {
#[allow(unused_mut)]
let mut object_231 = object.key("propertyUpdates").start_object();
for (key_232, value_233) in var_230 {
{
#[allow(unused_mut)]
let mut object_234 = object_231.key(key_232.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_property_request(
&mut object_234,
value_233,
)?;
object_234.finish();
}
}
object_231.finish();
}
if let Some(var_235) = &input.property_group_updates {
#[allow(unused_mut)]
let mut object_236 = object.key("propertyGroupUpdates").start_object();
for (key_237, value_238) in var_235 {
{
#[allow(unused_mut)]
let mut object_239 = object_236.key(key_237.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_component_property_group_request(
&mut object_239,
value_238,
)?;
object_239.finish();
}
}
object_236.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_parent_entity_update_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParentEntityUpdateRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_240) = &input.update_type {
object.key("updateType").string(var_240.as_str());
}
if let Some(var_241) = &input.parent_entity_id {
object.key("parentEntityId").string(var_241.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_entity_property_reference(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EntityPropertyReference,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_242) = &input.component_name {
object.key("componentName").string(var_242.as_str());
}
if let Some(var_243) = &input.external_id_property {
#[allow(unused_mut)]
let mut object_244 = object.key("externalIdProperty").start_object();
for (key_245, value_246) in var_243 {
{
object_244.key(key_245.as_str()).string(value_246.as_str());
}
}
object_244.finish();
}
if let Some(var_247) = &input.entity_id {
object.key("entityId").string(var_247.as_str());
}
if let Some(var_248) = &input.property_name {
object.key("propertyName").string(var_248.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_property_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PropertyValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_249) = &input.timestamp {
object
.key("timestamp")
.date_time(var_249, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_250) = &input.value {
#[allow(unused_mut)]
let mut object_251 = object.key("value").start_object();
crate::json_ser::serialize_structure_crate_model_data_value(&mut object_251, var_250)?;
object_251.finish();
}
if let Some(var_252) = &input.time {
object.key("time").string(var_252.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_data_connector(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataConnector,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_253) = &input.lambda {
#[allow(unused_mut)]
let mut object_254 = object.key("lambda").start_object();
crate::json_ser::serialize_structure_crate_model_lambda_function(&mut object_254, var_253)?;
object_254.finish();
}
if let Some(var_255) = &input.is_native {
object.key("isNative").boolean(*var_255);
}
Ok(())
}
pub fn serialize_structure_crate_model_data_type(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataType,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_256) = &input.r#type {
object.key("type").string(var_256.as_str());
}
if let Some(var_257) = &input.nested_type {
#[allow(unused_mut)]
let mut object_258 = object.key("nestedType").start_object();
crate::json_ser::serialize_structure_crate_model_data_type(&mut object_258, var_257)?;
object_258.finish();
}
if let Some(var_259) = &input.allowed_values {
let mut array_260 = object.key("allowedValues").start_array();
for item_261 in var_259 {
{
#[allow(unused_mut)]
let mut object_262 = array_260.value().start_object();
crate::json_ser::serialize_structure_crate_model_data_value(
&mut object_262,
item_261,
)?;
object_262.finish();
}
}
array_260.finish();
}
if let Some(var_263) = &input.unit_of_measure {
object.key("unitOfMeasure").string(var_263.as_str());
}
if let Some(var_264) = &input.relationship {
#[allow(unused_mut)]
let mut object_265 = object.key("relationship").start_object();
crate::json_ser::serialize_structure_crate_model_relationship(&mut object_265, var_264)?;
object_265.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_data_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_266) = &input.boolean_value {
object.key("booleanValue").boolean(*var_266);
}
if let Some(var_267) = &input.double_value {
object.key("doubleValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_267).into()),
);
}
if let Some(var_268) = &input.integer_value {
object.key("integerValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_268).into()),
);
}
if let Some(var_269) = &input.long_value {
object.key("longValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_269).into()),
);
}
if let Some(var_270) = &input.string_value {
object.key("stringValue").string(var_270.as_str());
}
if let Some(var_271) = &input.list_value {
let mut array_272 = object.key("listValue").start_array();
for item_273 in var_271 {
{
#[allow(unused_mut)]
let mut object_274 = array_272.value().start_object();
crate::json_ser::serialize_structure_crate_model_data_value(
&mut object_274,
item_273,
)?;
object_274.finish();
}
}
array_272.finish();
}
if let Some(var_275) = &input.map_value {
#[allow(unused_mut)]
let mut object_276 = object.key("mapValue").start_object();
for (key_277, value_278) in var_275 {
{
#[allow(unused_mut)]
let mut object_279 = object_276.key(key_277.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_data_value(
&mut object_279,
value_278,
)?;
object_279.finish();
}
}
object_276.finish();
}
if let Some(var_280) = &input.relationship_value {
#[allow(unused_mut)]
let mut object_281 = object.key("relationshipValue").start_object();
crate::json_ser::serialize_structure_crate_model_relationship_value(
&mut object_281,
var_280,
)?;
object_281.finish();
}
if let Some(var_282) = &input.expression {
object.key("expression").string(var_282.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_property_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PropertyRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_283) = &input.definition {
#[allow(unused_mut)]
let mut object_284 = object.key("definition").start_object();
crate::json_ser::serialize_structure_crate_model_property_definition_request(
&mut object_284,
var_283,
)?;
object_284.finish();
}
if let Some(var_285) = &input.value {
#[allow(unused_mut)]
let mut object_286 = object.key("value").start_object();
crate::json_ser::serialize_structure_crate_model_data_value(&mut object_286, var_285)?;
object_286.finish();
}
if let Some(var_287) = &input.update_type {
object.key("updateType").string(var_287.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_component_property_group_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComponentPropertyGroupRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_288) = &input.group_type {
object.key("groupType").string(var_288.as_str());
}
if let Some(var_289) = &input.property_names {
let mut array_290 = object.key("propertyNames").start_array();
for item_291 in var_289 {
{
array_290.value().string(item_291.as_str());
}
}
array_290.finish();
}
if let Some(var_292) = &input.update_type {
object.key("updateType").string(var_292.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_order_by(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OrderBy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_293) = &input.order {
object.key("order").string(var_293.as_str());
}
if let Some(var_294) = &input.property_name {
object.key("propertyName").string(var_294.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_lambda_function(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LambdaFunction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_295) = &input.arn {
object.key("arn").string(var_295.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_relationship(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Relationship,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_296) = &input.target_component_type_id {
object.key("targetComponentTypeId").string(var_296.as_str());
}
if let Some(var_297) = &input.relationship_type {
object.key("relationshipType").string(var_297.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_relationship_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RelationshipValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_298) = &input.target_entity_id {
object.key("targetEntityId").string(var_298.as_str());
}
if let Some(var_299) = &input.target_component_name {
object.key("targetComponentName").string(var_299.as_str());
}
Ok(())
}