pub fn serialize_structure_crate_model_create_component_data(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateComponentData,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_1) = &input.name {
object.key("name").string(var_1);
}
if let Some(var_2) = &input.source_id {
object.key("sourceId").string(var_2);
}
if let Some(var_3) = &input.component_type {
object.key("componentType").string(var_3);
}
if let Some(var_4) = &input.properties {
let mut object_5 = object.key("properties").start_object();
for (key_6, value_7) in var_4 {
{
let mut object_8 = object_5.key(key_6).start_object();
crate::json_ser::serialize_structure_crate_model_component_property(
&mut object_8,
value_7,
)?;
object_8.finish();
}
}
object_5.finish();
}
if let Some(var_9) = &input.children {
let mut array_10 = object.key("children").start_array();
for item_11 in var_9 {
{
let mut object_12 = array_10.value().start_object();
crate::json_ser::serialize_structure_crate_model_component_child(
&mut object_12,
item_11,
)?;
object_12.finish();
}
}
array_10.finish();
}
if let Some(var_13) = &input.variants {
let mut array_14 = object.key("variants").start_array();
for item_15 in var_13 {
{
let mut object_16 = array_14.value().start_object();
crate::json_ser::serialize_structure_crate_model_component_variant(
&mut object_16,
item_15,
)?;
object_16.finish();
}
}
array_14.finish();
}
if let Some(var_17) = &input.overrides {
let mut object_18 = object.key("overrides").start_object();
for (key_19, value_20) in var_17 {
{
let mut object_21 = object_18.key(key_19).start_object();
for (key_22, value_23) in value_20 {
{
object_21.key(key_22).string(value_23);
}
}
object_21.finish();
}
}
object_18.finish();
}
if let Some(var_24) = &input.binding_properties {
let mut object_25 = object.key("bindingProperties").start_object();
for (key_26, value_27) in var_24 {
{
let mut object_28 = object_25.key(key_26).start_object();
crate::json_ser::serialize_structure_crate_model_component_binding_properties_value(&mut object_28, value_27)?;
object_28.finish();
}
}
object_25.finish();
}
if let Some(var_29) = &input.collection_properties {
let mut object_30 = object.key("collectionProperties").start_object();
for (key_31, value_32) in var_29 {
{
let mut object_33 = object_30.key(key_31).start_object();
crate::json_ser::serialize_structure_crate_model_component_data_configuration(
&mut object_33,
value_32,
)?;
object_33.finish();
}
}
object_30.finish();
}
if let Some(var_34) = &input.tags {
let mut object_35 = object.key("tags").start_object();
for (key_36, value_37) in var_34 {
{
object_35.key(key_36).string(value_37);
}
}
object_35.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_create_theme_data(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateThemeData,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_38) = &input.name {
object.key("name").string(var_38);
}
if let Some(var_39) = &input.values {
let mut array_40 = object.key("values").start_array();
for item_41 in var_39 {
{
let mut object_42 = array_40.value().start_object();
crate::json_ser::serialize_structure_crate_model_theme_values(
&mut object_42,
item_41,
)?;
object_42.finish();
}
}
array_40.finish();
}
if let Some(var_43) = &input.overrides {
let mut array_44 = object.key("overrides").start_array();
for item_45 in var_43 {
{
let mut object_46 = array_44.value().start_object();
crate::json_ser::serialize_structure_crate_model_theme_values(
&mut object_46,
item_45,
)?;
object_46.finish();
}
}
array_44.finish();
}
if let Some(var_47) = &input.tags {
let mut object_48 = object.key("tags").start_object();
for (key_49, value_50) in var_47 {
{
object_48.key(key_49).string(value_50);
}
}
object_48.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_exchange_code_for_token_request_body(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExchangeCodeForTokenRequestBody,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_51) = &input.code {
object.key("code").string(var_51);
}
if let Some(var_52) = &input.redirect_uri {
object.key("redirectUri").string(var_52);
}
Ok(())
}
pub fn serialize_structure_crate_model_refresh_token_request_body(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RefreshTokenRequestBody,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_53) = &input.token {
object.key("token").string(var_53);
}
Ok(())
}
pub fn serialize_structure_crate_model_update_component_data(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateComponentData,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_54) = &input.id {
object.key("id").string(var_54);
}
if let Some(var_55) = &input.name {
object.key("name").string(var_55);
}
if let Some(var_56) = &input.source_id {
object.key("sourceId").string(var_56);
}
if let Some(var_57) = &input.component_type {
object.key("componentType").string(var_57);
}
if let Some(var_58) = &input.properties {
let mut object_59 = object.key("properties").start_object();
for (key_60, value_61) in var_58 {
{
let mut object_62 = object_59.key(key_60).start_object();
crate::json_ser::serialize_structure_crate_model_component_property(
&mut object_62,
value_61,
)?;
object_62.finish();
}
}
object_59.finish();
}
if let Some(var_63) = &input.children {
let mut array_64 = object.key("children").start_array();
for item_65 in var_63 {
{
let mut object_66 = array_64.value().start_object();
crate::json_ser::serialize_structure_crate_model_component_child(
&mut object_66,
item_65,
)?;
object_66.finish();
}
}
array_64.finish();
}
if let Some(var_67) = &input.variants {
let mut array_68 = object.key("variants").start_array();
for item_69 in var_67 {
{
let mut object_70 = array_68.value().start_object();
crate::json_ser::serialize_structure_crate_model_component_variant(
&mut object_70,
item_69,
)?;
object_70.finish();
}
}
array_68.finish();
}
if let Some(var_71) = &input.overrides {
let mut object_72 = object.key("overrides").start_object();
for (key_73, value_74) in var_71 {
{
let mut object_75 = object_72.key(key_73).start_object();
for (key_76, value_77) in value_74 {
{
object_75.key(key_76).string(value_77);
}
}
object_75.finish();
}
}
object_72.finish();
}
if let Some(var_78) = &input.binding_properties {
let mut object_79 = object.key("bindingProperties").start_object();
for (key_80, value_81) in var_78 {
{
let mut object_82 = object_79.key(key_80).start_object();
crate::json_ser::serialize_structure_crate_model_component_binding_properties_value(&mut object_82, value_81)?;
object_82.finish();
}
}
object_79.finish();
}
if let Some(var_83) = &input.collection_properties {
let mut object_84 = object.key("collectionProperties").start_object();
for (key_85, value_86) in var_83 {
{
let mut object_87 = object_84.key(key_85).start_object();
crate::json_ser::serialize_structure_crate_model_component_data_configuration(
&mut object_87,
value_86,
)?;
object_87.finish();
}
}
object_84.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_update_theme_data(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateThemeData,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_88) = &input.id {
object.key("id").string(var_88);
}
if let Some(var_89) = &input.name {
object.key("name").string(var_89);
}
if let Some(var_90) = &input.values {
let mut array_91 = object.key("values").start_array();
for item_92 in var_90 {
{
let mut object_93 = array_91.value().start_object();
crate::json_ser::serialize_structure_crate_model_theme_values(
&mut object_93,
item_92,
)?;
object_93.finish();
}
}
array_91.finish();
}
if let Some(var_94) = &input.overrides {
let mut array_95 = object.key("overrides").start_array();
for item_96 in var_94 {
{
let mut object_97 = array_95.value().start_object();
crate::json_ser::serialize_structure_crate_model_theme_values(
&mut object_97,
item_96,
)?;
object_97.finish();
}
}
array_95.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_component_property(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComponentProperty,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_98) = &input.value {
object.key("value").string(var_98);
}
if let Some(var_99) = &input.binding_properties {
let mut object_100 = object.key("bindingProperties").start_object();
crate::json_ser::serialize_structure_crate_model_component_property_binding_properties(
&mut object_100,
var_99,
)?;
object_100.finish();
}
if let Some(var_101) = &input.collection_binding_properties {
let mut object_102 = object.key("collectionBindingProperties").start_object();
crate::json_ser::serialize_structure_crate_model_component_property_binding_properties(
&mut object_102,
var_101,
)?;
object_102.finish();
}
if let Some(var_103) = &input.default_value {
object.key("defaultValue").string(var_103);
}
if let Some(var_104) = &input.model {
object.key("model").string(var_104);
}
if let Some(var_105) = &input.bindings {
let mut object_106 = object.key("bindings").start_object();
for (key_107, value_108) in var_105 {
{
let mut object_109 = object_106.key(key_107).start_object();
crate::json_ser::serialize_structure_crate_model_form_binding_element(
&mut object_109,
value_108,
)?;
object_109.finish();
}
}
object_106.finish();
}
if let Some(var_110) = &input.event {
object.key("event").string(var_110);
}
if let Some(var_111) = &input.user_attribute {
object.key("userAttribute").string(var_111);
}
if let Some(var_112) = &input.concat {
let mut array_113 = object.key("concat").start_array();
for item_114 in var_112 {
{
let mut object_115 = array_113.value().start_object();
crate::json_ser::serialize_structure_crate_model_component_property(
&mut object_115,
item_114,
)?;
object_115.finish();
}
}
array_113.finish();
}
if let Some(var_116) = &input.condition {
let mut object_117 = object.key("condition").start_object();
crate::json_ser::serialize_structure_crate_model_component_condition_property(
&mut object_117,
var_116,
)?;
object_117.finish();
}
if let Some(var_118) = &input.configured {
object.key("configured").boolean(*var_118);
}
if let Some(var_119) = &input.r#type {
object.key("type").string(var_119);
}
if let Some(var_120) = &input.imported_value {
object.key("importedValue").string(var_120);
}
Ok(())
}
pub fn serialize_structure_crate_model_component_child(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComponentChild,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_121) = &input.component_type {
object.key("componentType").string(var_121);
}
if let Some(var_122) = &input.name {
object.key("name").string(var_122);
}
if let Some(var_123) = &input.properties {
let mut object_124 = object.key("properties").start_object();
for (key_125, value_126) in var_123 {
{
let mut object_127 = object_124.key(key_125).start_object();
crate::json_ser::serialize_structure_crate_model_component_property(
&mut object_127,
value_126,
)?;
object_127.finish();
}
}
object_124.finish();
}
if let Some(var_128) = &input.children {
let mut array_129 = object.key("children").start_array();
for item_130 in var_128 {
{
let mut object_131 = array_129.value().start_object();
crate::json_ser::serialize_structure_crate_model_component_child(
&mut object_131,
item_130,
)?;
object_131.finish();
}
}
array_129.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_component_variant(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComponentVariant,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_132) = &input.variant_values {
let mut object_133 = object.key("variantValues").start_object();
for (key_134, value_135) in var_132 {
{
object_133.key(key_134).string(value_135);
}
}
object_133.finish();
}
if let Some(var_136) = &input.overrides {
let mut object_137 = object.key("overrides").start_object();
for (key_138, value_139) in var_136 {
{
let mut object_140 = object_137.key(key_138).start_object();
for (key_141, value_142) in value_139 {
{
object_140.key(key_141).string(value_142);
}
}
object_140.finish();
}
}
object_137.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_component_binding_properties_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComponentBindingPropertiesValue,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_143) = &input.r#type {
object.key("type").string(var_143);
}
if let Some(var_144) = &input.binding_properties {
let mut object_145 = object.key("bindingProperties").start_object();
crate::json_ser::serialize_structure_crate_model_component_binding_properties_value_properties(&mut object_145, var_144)?;
object_145.finish();
}
if let Some(var_146) = &input.default_value {
object.key("defaultValue").string(var_146);
}
Ok(())
}
pub fn serialize_structure_crate_model_component_data_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComponentDataConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_147) = &input.model {
object.key("model").string(var_147);
}
if let Some(var_148) = &input.sort {
let mut array_149 = object.key("sort").start_array();
for item_150 in var_148 {
{
let mut object_151 = array_149.value().start_object();
crate::json_ser::serialize_structure_crate_model_sort_property(
&mut object_151,
item_150,
)?;
object_151.finish();
}
}
array_149.finish();
}
if let Some(var_152) = &input.predicate {
let mut object_153 = object.key("predicate").start_object();
crate::json_ser::serialize_structure_crate_model_predicate(&mut object_153, var_152)?;
object_153.finish();
}
if let Some(var_154) = &input.identifiers {
let mut array_155 = object.key("identifiers").start_array();
for item_156 in var_154 {
{
array_155.value().string(item_156);
}
}
array_155.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_theme_values(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ThemeValues,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_157) = &input.key {
object.key("key").string(var_157);
}
if let Some(var_158) = &input.value {
let mut object_159 = object.key("value").start_object();
crate::json_ser::serialize_structure_crate_model_theme_value(&mut object_159, var_158)?;
object_159.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_component_property_binding_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComponentPropertyBindingProperties,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_160) = &input.property {
object.key("property").string(var_160);
}
if let Some(var_161) = &input.field {
object.key("field").string(var_161);
}
Ok(())
}
pub fn serialize_structure_crate_model_form_binding_element(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FormBindingElement,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_162) = &input.element {
object.key("element").string(var_162);
}
if let Some(var_163) = &input.property {
object.key("property").string(var_163);
}
Ok(())
}
pub fn serialize_structure_crate_model_component_condition_property(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComponentConditionProperty,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_164) = &input.property {
object.key("property").string(var_164);
}
if let Some(var_165) = &input.field {
object.key("field").string(var_165);
}
if let Some(var_166) = &input.operator {
object.key("operator").string(var_166);
}
if let Some(var_167) = &input.operand {
object.key("operand").string(var_167);
}
if let Some(var_168) = &input.then {
let mut object_169 = object.key("then").start_object();
crate::json_ser::serialize_structure_crate_model_component_property(
&mut object_169,
var_168,
)?;
object_169.finish();
}
if let Some(var_170) = &input.r#else {
let mut object_171 = object.key("else").start_object();
crate::json_ser::serialize_structure_crate_model_component_property(
&mut object_171,
var_170,
)?;
object_171.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_component_binding_properties_value_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComponentBindingPropertiesValueProperties,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_172) = &input.model {
object.key("model").string(var_172);
}
if let Some(var_173) = &input.field {
object.key("field").string(var_173);
}
if let Some(var_174) = &input.predicates {
let mut array_175 = object.key("predicates").start_array();
for item_176 in var_174 {
{
let mut object_177 = array_175.value().start_object();
crate::json_ser::serialize_structure_crate_model_predicate(
&mut object_177,
item_176,
)?;
object_177.finish();
}
}
array_175.finish();
}
if let Some(var_178) = &input.user_attribute {
object.key("userAttribute").string(var_178);
}
if let Some(var_179) = &input.bucket {
object.key("bucket").string(var_179);
}
if let Some(var_180) = &input.key {
object.key("key").string(var_180);
}
if let Some(var_181) = &input.default_value {
object.key("defaultValue").string(var_181);
}
Ok(())
}
pub fn serialize_structure_crate_model_sort_property(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SortProperty,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_182) = &input.field {
object.key("field").string(var_182);
}
if let Some(var_183) = &input.direction {
object.key("direction").string(var_183.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_predicate(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Predicate,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_184) = &input.or {
let mut array_185 = object.key("or").start_array();
for item_186 in var_184 {
{
let mut object_187 = array_185.value().start_object();
crate::json_ser::serialize_structure_crate_model_predicate(
&mut object_187,
item_186,
)?;
object_187.finish();
}
}
array_185.finish();
}
if let Some(var_188) = &input.and {
let mut array_189 = object.key("and").start_array();
for item_190 in var_188 {
{
let mut object_191 = array_189.value().start_object();
crate::json_ser::serialize_structure_crate_model_predicate(
&mut object_191,
item_190,
)?;
object_191.finish();
}
}
array_189.finish();
}
if let Some(var_192) = &input.field {
object.key("field").string(var_192);
}
if let Some(var_193) = &input.operator {
object.key("operator").string(var_193);
}
if let Some(var_194) = &input.operand {
object.key("operand").string(var_194);
}
Ok(())
}
pub fn serialize_structure_crate_model_theme_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ThemeValue,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_195) = &input.value {
object.key("value").string(var_195);
}
if let Some(var_196) = &input.children {
let mut array_197 = object.key("children").start_array();
for item_198 in var_196 {
{
let mut object_199 = array_197.value().start_object();
crate::json_ser::serialize_structure_crate_model_theme_values(
&mut object_199,
item_198,
)?;
object_199.finish();
}
}
array_197.finish();
}
Ok(())
}