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::error::SerializationError> {
if let Some(var_1) = &input.name {
object.key("name").string(var_1.as_str());
}
if let Some(var_2) = &input.source_id {
object.key("sourceId").string(var_2.as_str());
}
if let Some(var_3) = &input.component_type {
object.key("componentType").string(var_3.as_str());
}
if let Some(var_4) = &input.properties {
#[allow(unused_mut)]
let mut object_5 = object.key("properties").start_object();
for (key_6, value_7) in var_4 {
{
#[allow(unused_mut)]
let mut object_8 = object_5.key(key_6.as_str()).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 {
{
#[allow(unused_mut)]
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 {
{
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
let mut object_18 = object.key("overrides").start_object();
for (key_19, value_20) in var_17 {
{
#[allow(unused_mut)]
let mut object_21 = object_18.key(key_19.as_str()).start_object();
for (key_22, value_23) in value_20 {
{
object_21.key(key_22.as_str()).string(value_23.as_str());
}
}
object_21.finish();
}
}
object_18.finish();
}
if let Some(var_24) = &input.binding_properties {
#[allow(unused_mut)]
let mut object_25 = object.key("bindingProperties").start_object();
for (key_26, value_27) in var_24 {
{
#[allow(unused_mut)]
let mut object_28 = object_25.key(key_26.as_str()).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 {
#[allow(unused_mut)]
let mut object_30 = object.key("collectionProperties").start_object();
for (key_31, value_32) in var_29 {
{
#[allow(unused_mut)]
let mut object_33 = object_30.key(key_31.as_str()).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 {
#[allow(unused_mut)]
let mut object_35 = object.key("tags").start_object();
for (key_36, value_37) in var_34 {
{
object_35.key(key_36.as_str()).string(value_37.as_str());
}
}
object_35.finish();
}
if let Some(var_38) = &input.events {
#[allow(unused_mut)]
let mut object_39 = object.key("events").start_object();
for (key_40, value_41) in var_38 {
{
#[allow(unused_mut)]
let mut object_42 = object_39.key(key_40.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_component_event(
&mut object_42,
value_41,
)?;
object_42.finish();
}
}
object_39.finish();
}
if let Some(var_43) = &input.schema_version {
object.key("schemaVersion").string(var_43.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_create_form_data(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateFormData,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_44) = &input.name {
object.key("name").string(var_44.as_str());
}
if let Some(var_45) = &input.data_type {
#[allow(unused_mut)]
let mut object_46 = object.key("dataType").start_object();
crate::json_ser::serialize_structure_crate_model_form_data_type_config(
&mut object_46,
var_45,
)?;
object_46.finish();
}
if let Some(var_47) = &input.form_action_type {
object.key("formActionType").string(var_47.as_str());
}
if let Some(var_48) = &input.fields {
#[allow(unused_mut)]
let mut object_49 = object.key("fields").start_object();
for (key_50, value_51) in var_48 {
{
#[allow(unused_mut)]
let mut object_52 = object_49.key(key_50.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_field_config(
&mut object_52,
value_51,
)?;
object_52.finish();
}
}
object_49.finish();
}
if let Some(var_53) = &input.style {
#[allow(unused_mut)]
let mut object_54 = object.key("style").start_object();
crate::json_ser::serialize_structure_crate_model_form_style(&mut object_54, var_53)?;
object_54.finish();
}
if let Some(var_55) = &input.sectional_elements {
#[allow(unused_mut)]
let mut object_56 = object.key("sectionalElements").start_object();
for (key_57, value_58) in var_55 {
{
#[allow(unused_mut)]
let mut object_59 = object_56.key(key_57.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_sectional_element(
&mut object_59,
value_58,
)?;
object_59.finish();
}
}
object_56.finish();
}
if let Some(var_60) = &input.schema_version {
object.key("schemaVersion").string(var_60.as_str());
}
if let Some(var_61) = &input.cta {
#[allow(unused_mut)]
let mut object_62 = object.key("cta").start_object();
crate::json_ser::serialize_structure_crate_model_form_cta(&mut object_62, var_61)?;
object_62.finish();
}
if let Some(var_63) = &input.tags {
#[allow(unused_mut)]
let mut object_64 = object.key("tags").start_object();
for (key_65, value_66) in var_63 {
{
object_64.key(key_65.as_str()).string(value_66.as_str());
}
}
object_64.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::error::SerializationError> {
if let Some(var_67) = &input.name {
object.key("name").string(var_67.as_str());
}
if let Some(var_68) = &input.values {
let mut array_69 = object.key("values").start_array();
for item_70 in var_68 {
{
#[allow(unused_mut)]
let mut object_71 = array_69.value().start_object();
crate::json_ser::serialize_structure_crate_model_theme_values(
&mut object_71,
item_70,
)?;
object_71.finish();
}
}
array_69.finish();
}
if let Some(var_72) = &input.overrides {
let mut array_73 = object.key("overrides").start_array();
for item_74 in var_72 {
{
#[allow(unused_mut)]
let mut object_75 = array_73.value().start_object();
crate::json_ser::serialize_structure_crate_model_theme_values(
&mut object_75,
item_74,
)?;
object_75.finish();
}
}
array_73.finish();
}
if let Some(var_76) = &input.tags {
#[allow(unused_mut)]
let mut object_77 = object.key("tags").start_object();
for (key_78, value_79) in var_76 {
{
object_77.key(key_78.as_str()).string(value_79.as_str());
}
}
object_77.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::error::SerializationError> {
if let Some(var_80) = &input.code {
object.key("code").string(var_80.as_str());
}
if let Some(var_81) = &input.redirect_uri {
object.key("redirectUri").string(var_81.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_put_metadata_flag_body(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PutMetadataFlagBody,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_82) = &input.new_value {
object.key("newValue").string(var_82.as_str());
}
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::error::SerializationError> {
if let Some(var_83) = &input.token {
object.key("token").string(var_83.as_str());
}
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::error::SerializationError> {
if let Some(var_84) = &input.id {
object.key("id").string(var_84.as_str());
}
if let Some(var_85) = &input.name {
object.key("name").string(var_85.as_str());
}
if let Some(var_86) = &input.source_id {
object.key("sourceId").string(var_86.as_str());
}
if let Some(var_87) = &input.component_type {
object.key("componentType").string(var_87.as_str());
}
if let Some(var_88) = &input.properties {
#[allow(unused_mut)]
let mut object_89 = object.key("properties").start_object();
for (key_90, value_91) in var_88 {
{
#[allow(unused_mut)]
let mut object_92 = object_89.key(key_90.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_component_property(
&mut object_92,
value_91,
)?;
object_92.finish();
}
}
object_89.finish();
}
if let Some(var_93) = &input.children {
let mut array_94 = object.key("children").start_array();
for item_95 in var_93 {
{
#[allow(unused_mut)]
let mut object_96 = array_94.value().start_object();
crate::json_ser::serialize_structure_crate_model_component_child(
&mut object_96,
item_95,
)?;
object_96.finish();
}
}
array_94.finish();
}
if let Some(var_97) = &input.variants {
let mut array_98 = object.key("variants").start_array();
for item_99 in var_97 {
{
#[allow(unused_mut)]
let mut object_100 = array_98.value().start_object();
crate::json_ser::serialize_structure_crate_model_component_variant(
&mut object_100,
item_99,
)?;
object_100.finish();
}
}
array_98.finish();
}
if let Some(var_101) = &input.overrides {
#[allow(unused_mut)]
let mut object_102 = object.key("overrides").start_object();
for (key_103, value_104) in var_101 {
{
#[allow(unused_mut)]
let mut object_105 = object_102.key(key_103.as_str()).start_object();
for (key_106, value_107) in value_104 {
{
object_105.key(key_106.as_str()).string(value_107.as_str());
}
}
object_105.finish();
}
}
object_102.finish();
}
if let Some(var_108) = &input.binding_properties {
#[allow(unused_mut)]
let mut object_109 = object.key("bindingProperties").start_object();
for (key_110, value_111) in var_108 {
{
#[allow(unused_mut)]
let mut object_112 = object_109.key(key_110.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_component_binding_properties_value(&mut object_112, value_111)?;
object_112.finish();
}
}
object_109.finish();
}
if let Some(var_113) = &input.collection_properties {
#[allow(unused_mut)]
let mut object_114 = object.key("collectionProperties").start_object();
for (key_115, value_116) in var_113 {
{
#[allow(unused_mut)]
let mut object_117 = object_114.key(key_115.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_component_data_configuration(
&mut object_117,
value_116,
)?;
object_117.finish();
}
}
object_114.finish();
}
if let Some(var_118) = &input.events {
#[allow(unused_mut)]
let mut object_119 = object.key("events").start_object();
for (key_120, value_121) in var_118 {
{
#[allow(unused_mut)]
let mut object_122 = object_119.key(key_120.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_component_event(
&mut object_122,
value_121,
)?;
object_122.finish();
}
}
object_119.finish();
}
if let Some(var_123) = &input.schema_version {
object.key("schemaVersion").string(var_123.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_update_form_data(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateFormData,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_124) = &input.name {
object.key("name").string(var_124.as_str());
}
if let Some(var_125) = &input.data_type {
#[allow(unused_mut)]
let mut object_126 = object.key("dataType").start_object();
crate::json_ser::serialize_structure_crate_model_form_data_type_config(
&mut object_126,
var_125,
)?;
object_126.finish();
}
if let Some(var_127) = &input.form_action_type {
object.key("formActionType").string(var_127.as_str());
}
if let Some(var_128) = &input.fields {
#[allow(unused_mut)]
let mut object_129 = object.key("fields").start_object();
for (key_130, value_131) in var_128 {
{
#[allow(unused_mut)]
let mut object_132 = object_129.key(key_130.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_field_config(
&mut object_132,
value_131,
)?;
object_132.finish();
}
}
object_129.finish();
}
if let Some(var_133) = &input.style {
#[allow(unused_mut)]
let mut object_134 = object.key("style").start_object();
crate::json_ser::serialize_structure_crate_model_form_style(&mut object_134, var_133)?;
object_134.finish();
}
if let Some(var_135) = &input.sectional_elements {
#[allow(unused_mut)]
let mut object_136 = object.key("sectionalElements").start_object();
for (key_137, value_138) in var_135 {
{
#[allow(unused_mut)]
let mut object_139 = object_136.key(key_137.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_sectional_element(
&mut object_139,
value_138,
)?;
object_139.finish();
}
}
object_136.finish();
}
if let Some(var_140) = &input.schema_version {
object.key("schemaVersion").string(var_140.as_str());
}
if let Some(var_141) = &input.cta {
#[allow(unused_mut)]
let mut object_142 = object.key("cta").start_object();
crate::json_ser::serialize_structure_crate_model_form_cta(&mut object_142, var_141)?;
object_142.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::error::SerializationError> {
if let Some(var_143) = &input.id {
object.key("id").string(var_143.as_str());
}
if let Some(var_144) = &input.name {
object.key("name").string(var_144.as_str());
}
if let Some(var_145) = &input.values {
let mut array_146 = object.key("values").start_array();
for item_147 in var_145 {
{
#[allow(unused_mut)]
let mut object_148 = array_146.value().start_object();
crate::json_ser::serialize_structure_crate_model_theme_values(
&mut object_148,
item_147,
)?;
object_148.finish();
}
}
array_146.finish();
}
if let Some(var_149) = &input.overrides {
let mut array_150 = object.key("overrides").start_array();
for item_151 in var_149 {
{
#[allow(unused_mut)]
let mut object_152 = array_150.value().start_object();
crate::json_ser::serialize_structure_crate_model_theme_values(
&mut object_152,
item_151,
)?;
object_152.finish();
}
}
array_150.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::error::SerializationError> {
if let Some(var_153) = &input.value {
object.key("value").string(var_153.as_str());
}
if let Some(var_154) = &input.binding_properties {
#[allow(unused_mut)]
let mut object_155 = object.key("bindingProperties").start_object();
crate::json_ser::serialize_structure_crate_model_component_property_binding_properties(
&mut object_155,
var_154,
)?;
object_155.finish();
}
if let Some(var_156) = &input.collection_binding_properties {
#[allow(unused_mut)]
let mut object_157 = object.key("collectionBindingProperties").start_object();
crate::json_ser::serialize_structure_crate_model_component_property_binding_properties(
&mut object_157,
var_156,
)?;
object_157.finish();
}
if let Some(var_158) = &input.default_value {
object.key("defaultValue").string(var_158.as_str());
}
if let Some(var_159) = &input.model {
object.key("model").string(var_159.as_str());
}
if let Some(var_160) = &input.bindings {
#[allow(unused_mut)]
let mut object_161 = object.key("bindings").start_object();
for (key_162, value_163) in var_160 {
{
#[allow(unused_mut)]
let mut object_164 = object_161.key(key_162.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_form_binding_element(
&mut object_164,
value_163,
)?;
object_164.finish();
}
}
object_161.finish();
}
if let Some(var_165) = &input.event {
object.key("event").string(var_165.as_str());
}
if let Some(var_166) = &input.user_attribute {
object.key("userAttribute").string(var_166.as_str());
}
if let Some(var_167) = &input.concat {
let mut array_168 = object.key("concat").start_array();
for item_169 in var_167 {
{
#[allow(unused_mut)]
let mut object_170 = array_168.value().start_object();
crate::json_ser::serialize_structure_crate_model_component_property(
&mut object_170,
item_169,
)?;
object_170.finish();
}
}
array_168.finish();
}
if let Some(var_171) = &input.condition {
#[allow(unused_mut)]
let mut object_172 = object.key("condition").start_object();
crate::json_ser::serialize_structure_crate_model_component_condition_property(
&mut object_172,
var_171,
)?;
object_172.finish();
}
if let Some(var_173) = &input.configured {
object.key("configured").boolean(*var_173);
}
if let Some(var_174) = &input.r#type {
object.key("type").string(var_174.as_str());
}
if let Some(var_175) = &input.imported_value {
object.key("importedValue").string(var_175.as_str());
}
if let Some(var_176) = &input.component_name {
object.key("componentName").string(var_176.as_str());
}
if let Some(var_177) = &input.property {
object.key("property").string(var_177.as_str());
}
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::error::SerializationError> {
if let Some(var_178) = &input.component_type {
object.key("componentType").string(var_178.as_str());
}
if let Some(var_179) = &input.name {
object.key("name").string(var_179.as_str());
}
if let Some(var_180) = &input.properties {
#[allow(unused_mut)]
let mut object_181 = object.key("properties").start_object();
for (key_182, value_183) in var_180 {
{
#[allow(unused_mut)]
let mut object_184 = object_181.key(key_182.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_component_property(
&mut object_184,
value_183,
)?;
object_184.finish();
}
}
object_181.finish();
}
if let Some(var_185) = &input.children {
let mut array_186 = object.key("children").start_array();
for item_187 in var_185 {
{
#[allow(unused_mut)]
let mut object_188 = array_186.value().start_object();
crate::json_ser::serialize_structure_crate_model_component_child(
&mut object_188,
item_187,
)?;
object_188.finish();
}
}
array_186.finish();
}
if let Some(var_189) = &input.events {
#[allow(unused_mut)]
let mut object_190 = object.key("events").start_object();
for (key_191, value_192) in var_189 {
{
#[allow(unused_mut)]
let mut object_193 = object_190.key(key_191.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_component_event(
&mut object_193,
value_192,
)?;
object_193.finish();
}
}
object_190.finish();
}
if let Some(var_194) = &input.source_id {
object.key("sourceId").string(var_194.as_str());
}
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::error::SerializationError> {
if let Some(var_195) = &input.variant_values {
#[allow(unused_mut)]
let mut object_196 = object.key("variantValues").start_object();
for (key_197, value_198) in var_195 {
{
object_196.key(key_197.as_str()).string(value_198.as_str());
}
}
object_196.finish();
}
if let Some(var_199) = &input.overrides {
#[allow(unused_mut)]
let mut object_200 = object.key("overrides").start_object();
for (key_201, value_202) in var_199 {
{
#[allow(unused_mut)]
let mut object_203 = object_200.key(key_201.as_str()).start_object();
for (key_204, value_205) in value_202 {
{
object_203.key(key_204.as_str()).string(value_205.as_str());
}
}
object_203.finish();
}
}
object_200.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::error::SerializationError> {
if let Some(var_206) = &input.r#type {
object.key("type").string(var_206.as_str());
}
if let Some(var_207) = &input.binding_properties {
#[allow(unused_mut)]
let mut object_208 = object.key("bindingProperties").start_object();
crate::json_ser::serialize_structure_crate_model_component_binding_properties_value_properties(&mut object_208, var_207)?;
object_208.finish();
}
if let Some(var_209) = &input.default_value {
object.key("defaultValue").string(var_209.as_str());
}
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::error::SerializationError> {
if let Some(var_210) = &input.model {
object.key("model").string(var_210.as_str());
}
if let Some(var_211) = &input.sort {
let mut array_212 = object.key("sort").start_array();
for item_213 in var_211 {
{
#[allow(unused_mut)]
let mut object_214 = array_212.value().start_object();
crate::json_ser::serialize_structure_crate_model_sort_property(
&mut object_214,
item_213,
)?;
object_214.finish();
}
}
array_212.finish();
}
if let Some(var_215) = &input.predicate {
#[allow(unused_mut)]
let mut object_216 = object.key("predicate").start_object();
crate::json_ser::serialize_structure_crate_model_predicate(&mut object_216, var_215)?;
object_216.finish();
}
if let Some(var_217) = &input.identifiers {
let mut array_218 = object.key("identifiers").start_array();
for item_219 in var_217 {
{
array_218.value().string(item_219.as_str());
}
}
array_218.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_component_event(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComponentEvent,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_220) = &input.action {
object.key("action").string(var_220.as_str());
}
if let Some(var_221) = &input.parameters {
#[allow(unused_mut)]
let mut object_222 = object.key("parameters").start_object();
crate::json_ser::serialize_structure_crate_model_action_parameters(
&mut object_222,
var_221,
)?;
object_222.finish();
}
if let Some(var_223) = &input.binding_event {
object.key("bindingEvent").string(var_223.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_form_data_type_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FormDataTypeConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_224) = &input.data_source_type {
object.key("dataSourceType").string(var_224.as_str());
}
if let Some(var_225) = &input.data_type_name {
object.key("dataTypeName").string(var_225.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_field_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FieldConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_226) = &input.label {
object.key("label").string(var_226.as_str());
}
if let Some(var_227) = &input.position {
#[allow(unused_mut)]
let mut object_228 = object.key("position").start_object();
crate::json_ser::serialize_union_crate_model_field_position(&mut object_228, var_227)?;
object_228.finish();
}
if let Some(var_229) = &input.excluded {
object.key("excluded").boolean(*var_229);
}
if let Some(var_230) = &input.input_type {
#[allow(unused_mut)]
let mut object_231 = object.key("inputType").start_object();
crate::json_ser::serialize_structure_crate_model_field_input_config(
&mut object_231,
var_230,
)?;
object_231.finish();
}
if let Some(var_232) = &input.validations {
let mut array_233 = object.key("validations").start_array();
for item_234 in var_232 {
{
#[allow(unused_mut)]
let mut object_235 = array_233.value().start_object();
crate::json_ser::serialize_structure_crate_model_field_validation_configuration(
&mut object_235,
item_234,
)?;
object_235.finish();
}
}
array_233.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_form_style(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FormStyle,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_236) = &input.horizontal_gap {
#[allow(unused_mut)]
let mut object_237 = object.key("horizontalGap").start_object();
crate::json_ser::serialize_union_crate_model_form_style_config(&mut object_237, var_236)?;
object_237.finish();
}
if let Some(var_238) = &input.vertical_gap {
#[allow(unused_mut)]
let mut object_239 = object.key("verticalGap").start_object();
crate::json_ser::serialize_union_crate_model_form_style_config(&mut object_239, var_238)?;
object_239.finish();
}
if let Some(var_240) = &input.outer_padding {
#[allow(unused_mut)]
let mut object_241 = object.key("outerPadding").start_object();
crate::json_ser::serialize_union_crate_model_form_style_config(&mut object_241, var_240)?;
object_241.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sectional_element(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SectionalElement,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_242) = &input.r#type {
object.key("type").string(var_242.as_str());
}
if let Some(var_243) = &input.position {
#[allow(unused_mut)]
let mut object_244 = object.key("position").start_object();
crate::json_ser::serialize_union_crate_model_field_position(&mut object_244, var_243)?;
object_244.finish();
}
if let Some(var_245) = &input.text {
object.key("text").string(var_245.as_str());
}
if let Some(var_246) = &input.level {
object.key("level").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_246).into()),
);
}
if let Some(var_247) = &input.orientation {
object.key("orientation").string(var_247.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_form_cta(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FormCta,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_248) = &input.position {
object.key("position").string(var_248.as_str());
}
if let Some(var_249) = &input.clear {
#[allow(unused_mut)]
let mut object_250 = object.key("clear").start_object();
crate::json_ser::serialize_structure_crate_model_form_button(&mut object_250, var_249)?;
object_250.finish();
}
if let Some(var_251) = &input.cancel {
#[allow(unused_mut)]
let mut object_252 = object.key("cancel").start_object();
crate::json_ser::serialize_structure_crate_model_form_button(&mut object_252, var_251)?;
object_252.finish();
}
if let Some(var_253) = &input.submit {
#[allow(unused_mut)]
let mut object_254 = object.key("submit").start_object();
crate::json_ser::serialize_structure_crate_model_form_button(&mut object_254, var_253)?;
object_254.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::error::SerializationError> {
if let Some(var_255) = &input.key {
object.key("key").string(var_255.as_str());
}
if let Some(var_256) = &input.value {
#[allow(unused_mut)]
let mut object_257 = object.key("value").start_object();
crate::json_ser::serialize_structure_crate_model_theme_value(&mut object_257, var_256)?;
object_257.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::error::SerializationError> {
if let Some(var_258) = &input.property {
object.key("property").string(var_258.as_str());
}
if let Some(var_259) = &input.field {
object.key("field").string(var_259.as_str());
}
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::error::SerializationError> {
if let Some(var_260) = &input.element {
object.key("element").string(var_260.as_str());
}
if let Some(var_261) = &input.property {
object.key("property").string(var_261.as_str());
}
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::error::SerializationError> {
if let Some(var_262) = &input.property {
object.key("property").string(var_262.as_str());
}
if let Some(var_263) = &input.field {
object.key("field").string(var_263.as_str());
}
if let Some(var_264) = &input.operator {
object.key("operator").string(var_264.as_str());
}
if let Some(var_265) = &input.operand {
object.key("operand").string(var_265.as_str());
}
if let Some(var_266) = &input.then {
#[allow(unused_mut)]
let mut object_267 = object.key("then").start_object();
crate::json_ser::serialize_structure_crate_model_component_property(
&mut object_267,
var_266,
)?;
object_267.finish();
}
if let Some(var_268) = &input.r#else {
#[allow(unused_mut)]
let mut object_269 = object.key("else").start_object();
crate::json_ser::serialize_structure_crate_model_component_property(
&mut object_269,
var_268,
)?;
object_269.finish();
}
if let Some(var_270) = &input.operand_type {
object.key("operandType").string(var_270.as_str());
}
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::error::SerializationError> {
if let Some(var_271) = &input.model {
object.key("model").string(var_271.as_str());
}
if let Some(var_272) = &input.field {
object.key("field").string(var_272.as_str());
}
if let Some(var_273) = &input.predicates {
let mut array_274 = object.key("predicates").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_predicate(
&mut object_276,
item_275,
)?;
object_276.finish();
}
}
array_274.finish();
}
if let Some(var_277) = &input.user_attribute {
object.key("userAttribute").string(var_277.as_str());
}
if let Some(var_278) = &input.bucket {
object.key("bucket").string(var_278.as_str());
}
if let Some(var_279) = &input.key {
object.key("key").string(var_279.as_str());
}
if let Some(var_280) = &input.default_value {
object.key("defaultValue").string(var_280.as_str());
}
if let Some(var_281) = &input.slot_name {
object.key("slotName").string(var_281.as_str());
}
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::error::SerializationError> {
if let Some(var_282) = &input.field {
object.key("field").string(var_282.as_str());
}
if let Some(var_283) = &input.direction {
object.key("direction").string(var_283.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::error::SerializationError> {
if let Some(var_284) = &input.or {
let mut array_285 = object.key("or").start_array();
for item_286 in var_284 {
{
#[allow(unused_mut)]
let mut object_287 = array_285.value().start_object();
crate::json_ser::serialize_structure_crate_model_predicate(
&mut object_287,
item_286,
)?;
object_287.finish();
}
}
array_285.finish();
}
if let Some(var_288) = &input.and {
let mut array_289 = object.key("and").start_array();
for item_290 in var_288 {
{
#[allow(unused_mut)]
let mut object_291 = array_289.value().start_object();
crate::json_ser::serialize_structure_crate_model_predicate(
&mut object_291,
item_290,
)?;
object_291.finish();
}
}
array_289.finish();
}
if let Some(var_292) = &input.field {
object.key("field").string(var_292.as_str());
}
if let Some(var_293) = &input.operator {
object.key("operator").string(var_293.as_str());
}
if let Some(var_294) = &input.operand {
object.key("operand").string(var_294.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_action_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ActionParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_295) = &input.r#type {
#[allow(unused_mut)]
let mut object_296 = object.key("type").start_object();
crate::json_ser::serialize_structure_crate_model_component_property(
&mut object_296,
var_295,
)?;
object_296.finish();
}
if let Some(var_297) = &input.url {
#[allow(unused_mut)]
let mut object_298 = object.key("url").start_object();
crate::json_ser::serialize_structure_crate_model_component_property(
&mut object_298,
var_297,
)?;
object_298.finish();
}
if let Some(var_299) = &input.anchor {
#[allow(unused_mut)]
let mut object_300 = object.key("anchor").start_object();
crate::json_ser::serialize_structure_crate_model_component_property(
&mut object_300,
var_299,
)?;
object_300.finish();
}
if let Some(var_301) = &input.target {
#[allow(unused_mut)]
let mut object_302 = object.key("target").start_object();
crate::json_ser::serialize_structure_crate_model_component_property(
&mut object_302,
var_301,
)?;
object_302.finish();
}
if let Some(var_303) = &input.global {
#[allow(unused_mut)]
let mut object_304 = object.key("global").start_object();
crate::json_ser::serialize_structure_crate_model_component_property(
&mut object_304,
var_303,
)?;
object_304.finish();
}
if let Some(var_305) = &input.model {
object.key("model").string(var_305.as_str());
}
if let Some(var_306) = &input.id {
#[allow(unused_mut)]
let mut object_307 = object.key("id").start_object();
crate::json_ser::serialize_structure_crate_model_component_property(
&mut object_307,
var_306,
)?;
object_307.finish();
}
if let Some(var_308) = &input.fields {
#[allow(unused_mut)]
let mut object_309 = object.key("fields").start_object();
for (key_310, value_311) in var_308 {
{
#[allow(unused_mut)]
let mut object_312 = object_309.key(key_310.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_component_property(
&mut object_312,
value_311,
)?;
object_312.finish();
}
}
object_309.finish();
}
if let Some(var_313) = &input.state {
#[allow(unused_mut)]
let mut object_314 = object.key("state").start_object();
crate::json_ser::serialize_structure_crate_model_mutation_action_set_state_parameter(
&mut object_314,
var_313,
)?;
object_314.finish();
}
Ok(())
}
pub fn serialize_union_crate_model_field_position(
object_228: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FieldPosition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::FieldPosition::Fixed(inner) => {
object_228.key("fixed").string(inner.as_str());
}
crate::model::FieldPosition::RightOf(inner) => {
object_228.key("rightOf").string(inner.as_str());
}
crate::model::FieldPosition::Below(inner) => {
object_228.key("below").string(inner.as_str());
}
crate::model::FieldPosition::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"FieldPosition",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_field_input_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FieldInputConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_315) = &input.r#type {
object.key("type").string(var_315.as_str());
}
if let Some(var_316) = &input.required {
object.key("required").boolean(*var_316);
}
if let Some(var_317) = &input.read_only {
object.key("readOnly").boolean(*var_317);
}
if let Some(var_318) = &input.placeholder {
object.key("placeholder").string(var_318.as_str());
}
if let Some(var_319) = &input.default_value {
object.key("defaultValue").string(var_319.as_str());
}
if let Some(var_320) = &input.descriptive_text {
object.key("descriptiveText").string(var_320.as_str());
}
if let Some(var_321) = &input.default_checked {
object.key("defaultChecked").boolean(*var_321);
}
if let Some(var_322) = &input.default_country_code {
object.key("defaultCountryCode").string(var_322.as_str());
}
if let Some(var_323) = &input.value_mappings {
#[allow(unused_mut)]
let mut object_324 = object.key("valueMappings").start_object();
crate::json_ser::serialize_structure_crate_model_value_mappings(&mut object_324, var_323)?;
object_324.finish();
}
if let Some(var_325) = &input.name {
object.key("name").string(var_325.as_str());
}
if let Some(var_326) = &input.min_value {
object.key("minValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_326).into()),
);
}
if let Some(var_327) = &input.max_value {
object.key("maxValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_327).into()),
);
}
if let Some(var_328) = &input.step {
object.key("step").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_328).into()),
);
}
if let Some(var_329) = &input.value {
object.key("value").string(var_329.as_str());
}
if let Some(var_330) = &input.is_array {
object.key("isArray").boolean(*var_330);
}
Ok(())
}
pub fn serialize_structure_crate_model_field_validation_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FieldValidationConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_331) = &input.r#type {
object.key("type").string(var_331.as_str());
}
if let Some(var_332) = &input.str_values {
let mut array_333 = object.key("strValues").start_array();
for item_334 in var_332 {
{
array_333.value().string(item_334.as_str());
}
}
array_333.finish();
}
if let Some(var_335) = &input.num_values {
let mut array_336 = object.key("numValues").start_array();
for item_337 in var_335 {
{
array_336.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*item_337).into()),
);
}
}
array_336.finish();
}
if let Some(var_338) = &input.validation_message {
object.key("validationMessage").string(var_338.as_str());
}
Ok(())
}
pub fn serialize_union_crate_model_form_style_config(
object_237: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FormStyleConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::FormStyleConfig::TokenReference(inner) => {
object_237.key("tokenReference").string(inner.as_str());
}
crate::model::FormStyleConfig::Value(inner) => {
object_237.key("value").string(inner.as_str());
}
crate::model::FormStyleConfig::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"FormStyleConfig",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_form_button(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FormButton,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_339) = &input.excluded {
object.key("excluded").boolean(*var_339);
}
if let Some(var_340) = &input.children {
object.key("children").string(var_340.as_str());
}
if let Some(var_341) = &input.position {
#[allow(unused_mut)]
let mut object_342 = object.key("position").start_object();
crate::json_ser::serialize_union_crate_model_field_position(&mut object_342, var_341)?;
object_342.finish();
}
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::error::SerializationError> {
if let Some(var_343) = &input.value {
object.key("value").string(var_343.as_str());
}
if let Some(var_344) = &input.children {
let mut array_345 = object.key("children").start_array();
for item_346 in var_344 {
{
#[allow(unused_mut)]
let mut object_347 = array_345.value().start_object();
crate::json_ser::serialize_structure_crate_model_theme_values(
&mut object_347,
item_346,
)?;
object_347.finish();
}
}
array_345.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_mutation_action_set_state_parameter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MutationActionSetStateParameter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_348) = &input.component_name {
object.key("componentName").string(var_348.as_str());
}
if let Some(var_349) = &input.property {
object.key("property").string(var_349.as_str());
}
if let Some(var_350) = &input.set {
#[allow(unused_mut)]
let mut object_351 = object.key("set").start_object();
crate::json_ser::serialize_structure_crate_model_component_property(
&mut object_351,
var_350,
)?;
object_351.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_value_mappings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ValueMappings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_352) = &input.values {
let mut array_353 = object.key("values").start_array();
for item_354 in var_352 {
{
#[allow(unused_mut)]
let mut object_355 = array_353.value().start_object();
crate::json_ser::serialize_structure_crate_model_value_mapping(
&mut object_355,
item_354,
)?;
object_355.finish();
}
}
array_353.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_value_mapping(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ValueMapping,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_356) = &input.display_value {
#[allow(unused_mut)]
let mut object_357 = object.key("displayValue").start_object();
crate::json_ser::serialize_structure_crate_model_form_input_value_property(
&mut object_357,
var_356,
)?;
object_357.finish();
}
if let Some(var_358) = &input.value {
#[allow(unused_mut)]
let mut object_359 = object.key("value").start_object();
crate::json_ser::serialize_structure_crate_model_form_input_value_property(
&mut object_359,
var_358,
)?;
object_359.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_form_input_value_property(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FormInputValueProperty,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_360) = &input.value {
object.key("value").string(var_360.as_str());
}
Ok(())
}