pub fn serialize_structure_crate_input_create_account_customization_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAccountCustomizationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.account_customization {
#[allow(unused_mut)]
let mut object_2 = object.key("AccountCustomization").start_object();
crate::json_ser::serialize_structure_crate_model_account_customization(
&mut object_2,
var_1,
)?;
object_2.finish();
}
if let Some(var_3) = &input.tags {
let mut array_4 = object.key("Tags").start_array();
for item_5 in var_3 {
{
#[allow(unused_mut)]
let mut object_6 = array_4.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_6, item_5)?;
object_6.finish();
}
}
array_4.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_account_subscription_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAccountSubscriptionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_7) = &input.account_name {
object.key("AccountName").string(var_7.as_str());
}
if let Some(var_8) = &input.active_directory_name {
object.key("ActiveDirectoryName").string(var_8.as_str());
}
if let Some(var_9) = &input.admin_group {
let mut array_10 = object.key("AdminGroup").start_array();
for item_11 in var_9 {
{
array_10.value().string(item_11.as_str());
}
}
array_10.finish();
}
if let Some(var_12) = &input.authentication_method {
object.key("AuthenticationMethod").string(var_12.as_str());
}
if let Some(var_13) = &input.author_group {
let mut array_14 = object.key("AuthorGroup").start_array();
for item_15 in var_13 {
{
array_14.value().string(item_15.as_str());
}
}
array_14.finish();
}
if let Some(var_16) = &input.contact_number {
object.key("ContactNumber").string(var_16.as_str());
}
if let Some(var_17) = &input.directory_id {
object.key("DirectoryId").string(var_17.as_str());
}
if let Some(var_18) = &input.edition {
object.key("Edition").string(var_18.as_str());
}
if let Some(var_19) = &input.email_address {
object.key("EmailAddress").string(var_19.as_str());
}
if let Some(var_20) = &input.first_name {
object.key("FirstName").string(var_20.as_str());
}
if let Some(var_21) = &input.last_name {
object.key("LastName").string(var_21.as_str());
}
if let Some(var_22) = &input.notification_email {
object.key("NotificationEmail").string(var_22.as_str());
}
if let Some(var_23) = &input.reader_group {
let mut array_24 = object.key("ReaderGroup").start_array();
for item_25 in var_23 {
{
array_24.value().string(item_25.as_str());
}
}
array_24.finish();
}
if let Some(var_26) = &input.realm {
object.key("Realm").string(var_26.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_analysis_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAnalysisInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_27) = &input.definition {
#[allow(unused_mut)]
let mut object_28 = object.key("Definition").start_object();
crate::json_ser::serialize_structure_crate_model_analysis_definition(
&mut object_28,
var_27,
)?;
object_28.finish();
}
if let Some(var_29) = &input.name {
object.key("Name").string(var_29.as_str());
}
if let Some(var_30) = &input.parameters {
#[allow(unused_mut)]
let mut object_31 = object.key("Parameters").start_object();
crate::json_ser::serialize_structure_crate_model_parameters(&mut object_31, var_30)?;
object_31.finish();
}
if let Some(var_32) = &input.permissions {
let mut array_33 = object.key("Permissions").start_array();
for item_34 in var_32 {
{
#[allow(unused_mut)]
let mut object_35 = array_33.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_permission(
&mut object_35,
item_34,
)?;
object_35.finish();
}
}
array_33.finish();
}
if let Some(var_36) = &input.source_entity {
#[allow(unused_mut)]
let mut object_37 = object.key("SourceEntity").start_object();
crate::json_ser::serialize_structure_crate_model_analysis_source_entity(
&mut object_37,
var_36,
)?;
object_37.finish();
}
if let Some(var_38) = &input.tags {
let mut array_39 = object.key("Tags").start_array();
for item_40 in var_38 {
{
#[allow(unused_mut)]
let mut object_41 = array_39.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_41, item_40)?;
object_41.finish();
}
}
array_39.finish();
}
if let Some(var_42) = &input.theme_arn {
object.key("ThemeArn").string(var_42.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_dashboard_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDashboardInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_43) = &input.dashboard_publish_options {
#[allow(unused_mut)]
let mut object_44 = object.key("DashboardPublishOptions").start_object();
crate::json_ser::serialize_structure_crate_model_dashboard_publish_options(
&mut object_44,
var_43,
)?;
object_44.finish();
}
if let Some(var_45) = &input.definition {
#[allow(unused_mut)]
let mut object_46 = object.key("Definition").start_object();
crate::json_ser::serialize_structure_crate_model_dashboard_version_definition(
&mut object_46,
var_45,
)?;
object_46.finish();
}
if let Some(var_47) = &input.name {
object.key("Name").string(var_47.as_str());
}
if let Some(var_48) = &input.parameters {
#[allow(unused_mut)]
let mut object_49 = object.key("Parameters").start_object();
crate::json_ser::serialize_structure_crate_model_parameters(&mut object_49, var_48)?;
object_49.finish();
}
if let Some(var_50) = &input.permissions {
let mut array_51 = object.key("Permissions").start_array();
for item_52 in var_50 {
{
#[allow(unused_mut)]
let mut object_53 = array_51.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_permission(
&mut object_53,
item_52,
)?;
object_53.finish();
}
}
array_51.finish();
}
if let Some(var_54) = &input.source_entity {
#[allow(unused_mut)]
let mut object_55 = object.key("SourceEntity").start_object();
crate::json_ser::serialize_structure_crate_model_dashboard_source_entity(
&mut object_55,
var_54,
)?;
object_55.finish();
}
if let Some(var_56) = &input.tags {
let mut array_57 = object.key("Tags").start_array();
for item_58 in var_56 {
{
#[allow(unused_mut)]
let mut object_59 = array_57.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_59, item_58)?;
object_59.finish();
}
}
array_57.finish();
}
if let Some(var_60) = &input.theme_arn {
object.key("ThemeArn").string(var_60.as_str());
}
if let Some(var_61) = &input.version_description {
object.key("VersionDescription").string(var_61.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_data_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDataSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_62) = &input.column_groups {
let mut array_63 = object.key("ColumnGroups").start_array();
for item_64 in var_62 {
{
#[allow(unused_mut)]
let mut object_65 = array_63.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_group(
&mut object_65,
item_64,
)?;
object_65.finish();
}
}
array_63.finish();
}
if let Some(var_66) = &input.column_level_permission_rules {
let mut array_67 = object.key("ColumnLevelPermissionRules").start_array();
for item_68 in var_66 {
{
#[allow(unused_mut)]
let mut object_69 = array_67.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_level_permission_rule(
&mut object_69,
item_68,
)?;
object_69.finish();
}
}
array_67.finish();
}
if let Some(var_70) = &input.data_set_id {
object.key("DataSetId").string(var_70.as_str());
}
if let Some(var_71) = &input.data_set_usage_configuration {
#[allow(unused_mut)]
let mut object_72 = object.key("DataSetUsageConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_data_set_usage_configuration(
&mut object_72,
var_71,
)?;
object_72.finish();
}
if let Some(var_73) = &input.field_folders {
#[allow(unused_mut)]
let mut object_74 = object.key("FieldFolders").start_object();
for (key_75, value_76) in var_73 {
{
#[allow(unused_mut)]
let mut object_77 = object_74.key(key_75.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_field_folder(
&mut object_77,
value_76,
)?;
object_77.finish();
}
}
object_74.finish();
}
if let Some(var_78) = &input.import_mode {
object.key("ImportMode").string(var_78.as_str());
}
if let Some(var_79) = &input.logical_table_map {
#[allow(unused_mut)]
let mut object_80 = object.key("LogicalTableMap").start_object();
for (key_81, value_82) in var_79 {
{
#[allow(unused_mut)]
let mut object_83 = object_80.key(key_81.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_logical_table(
&mut object_83,
value_82,
)?;
object_83.finish();
}
}
object_80.finish();
}
if let Some(var_84) = &input.name {
object.key("Name").string(var_84.as_str());
}
if let Some(var_85) = &input.permissions {
let mut array_86 = object.key("Permissions").start_array();
for item_87 in var_85 {
{
#[allow(unused_mut)]
let mut object_88 = array_86.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_permission(
&mut object_88,
item_87,
)?;
object_88.finish();
}
}
array_86.finish();
}
if let Some(var_89) = &input.physical_table_map {
#[allow(unused_mut)]
let mut object_90 = object.key("PhysicalTableMap").start_object();
for (key_91, value_92) in var_89 {
{
#[allow(unused_mut)]
let mut object_93 = object_90.key(key_91.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_physical_table(
&mut object_93,
value_92,
)?;
object_93.finish();
}
}
object_90.finish();
}
if let Some(var_94) = &input.row_level_permission_data_set {
#[allow(unused_mut)]
let mut object_95 = object.key("RowLevelPermissionDataSet").start_object();
crate::json_ser::serialize_structure_crate_model_row_level_permission_data_set(
&mut object_95,
var_94,
)?;
object_95.finish();
}
if let Some(var_96) = &input.row_level_permission_tag_configuration {
#[allow(unused_mut)]
let mut object_97 = object
.key("RowLevelPermissionTagConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_row_level_permission_tag_configuration(
&mut object_97,
var_96,
)?;
object_97.finish();
}
if let Some(var_98) = &input.tags {
let mut array_99 = object.key("Tags").start_array();
for item_100 in var_98 {
{
#[allow(unused_mut)]
let mut object_101 = array_99.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_101, item_100)?;
object_101.finish();
}
}
array_99.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_data_source_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDataSourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_102) = &input.credentials {
#[allow(unused_mut)]
let mut object_103 = object.key("Credentials").start_object();
crate::json_ser::serialize_structure_crate_model_data_source_credentials(
&mut object_103,
var_102,
)?;
object_103.finish();
}
if let Some(var_104) = &input.data_source_id {
object.key("DataSourceId").string(var_104.as_str());
}
if let Some(var_105) = &input.data_source_parameters {
#[allow(unused_mut)]
let mut object_106 = object.key("DataSourceParameters").start_object();
crate::json_ser::serialize_union_crate_model_data_source_parameters(
&mut object_106,
var_105,
)?;
object_106.finish();
}
if let Some(var_107) = &input.name {
object.key("Name").string(var_107.as_str());
}
if let Some(var_108) = &input.permissions {
let mut array_109 = object.key("Permissions").start_array();
for item_110 in var_108 {
{
#[allow(unused_mut)]
let mut object_111 = array_109.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_permission(
&mut object_111,
item_110,
)?;
object_111.finish();
}
}
array_109.finish();
}
if let Some(var_112) = &input.ssl_properties {
#[allow(unused_mut)]
let mut object_113 = object.key("SslProperties").start_object();
crate::json_ser::serialize_structure_crate_model_ssl_properties(&mut object_113, var_112)?;
object_113.finish();
}
if let Some(var_114) = &input.tags {
let mut array_115 = object.key("Tags").start_array();
for item_116 in var_114 {
{
#[allow(unused_mut)]
let mut object_117 = array_115.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_117, item_116)?;
object_117.finish();
}
}
array_115.finish();
}
if let Some(var_118) = &input.r#type {
object.key("Type").string(var_118.as_str());
}
if let Some(var_119) = &input.vpc_connection_properties {
#[allow(unused_mut)]
let mut object_120 = object.key("VpcConnectionProperties").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_connection_properties(
&mut object_120,
var_119,
)?;
object_120.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_folder_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFolderInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_121) = &input.folder_type {
object.key("FolderType").string(var_121.as_str());
}
if let Some(var_122) = &input.name {
object.key("Name").string(var_122.as_str());
}
if let Some(var_123) = &input.parent_folder_arn {
object.key("ParentFolderArn").string(var_123.as_str());
}
if let Some(var_124) = &input.permissions {
let mut array_125 = object.key("Permissions").start_array();
for item_126 in var_124 {
{
#[allow(unused_mut)]
let mut object_127 = array_125.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_permission(
&mut object_127,
item_126,
)?;
object_127.finish();
}
}
array_125.finish();
}
if let Some(var_128) = &input.tags {
let mut array_129 = object.key("Tags").start_array();
for item_130 in var_128 {
{
#[allow(unused_mut)]
let mut object_131 = array_129.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_131, item_130)?;
object_131.finish();
}
}
array_129.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_132) = &input.description {
object.key("Description").string(var_132.as_str());
}
if let Some(var_133) = &input.group_name {
object.key("GroupName").string(var_133.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_iam_policy_assignment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateIamPolicyAssignmentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_134) = &input.assignment_name {
object.key("AssignmentName").string(var_134.as_str());
}
if let Some(var_135) = &input.assignment_status {
object.key("AssignmentStatus").string(var_135.as_str());
}
if let Some(var_136) = &input.identities {
#[allow(unused_mut)]
let mut object_137 = object.key("Identities").start_object();
for (key_138, value_139) in var_136 {
{
let mut array_140 = object_137.key(key_138.as_str()).start_array();
for item_141 in value_139 {
{
array_140.value().string(item_141.as_str());
}
}
array_140.finish();
}
}
object_137.finish();
}
if let Some(var_142) = &input.policy_arn {
object.key("PolicyArn").string(var_142.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_ingestion_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateIngestionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_143) = &input.ingestion_type {
object.key("IngestionType").string(var_143.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_namespace_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateNamespaceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_144) = &input.identity_store {
object.key("IdentityStore").string(var_144.as_str());
}
if let Some(var_145) = &input.namespace {
object.key("Namespace").string(var_145.as_str());
}
if let Some(var_146) = &input.tags {
let mut array_147 = object.key("Tags").start_array();
for item_148 in var_146 {
{
#[allow(unused_mut)]
let mut object_149 = array_147.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_149, item_148)?;
object_149.finish();
}
}
array_147.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_template_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateTemplateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_150) = &input.definition {
#[allow(unused_mut)]
let mut object_151 = object.key("Definition").start_object();
crate::json_ser::serialize_structure_crate_model_template_version_definition(
&mut object_151,
var_150,
)?;
object_151.finish();
}
if let Some(var_152) = &input.name {
object.key("Name").string(var_152.as_str());
}
if let Some(var_153) = &input.permissions {
let mut array_154 = object.key("Permissions").start_array();
for item_155 in var_153 {
{
#[allow(unused_mut)]
let mut object_156 = array_154.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_permission(
&mut object_156,
item_155,
)?;
object_156.finish();
}
}
array_154.finish();
}
if let Some(var_157) = &input.source_entity {
#[allow(unused_mut)]
let mut object_158 = object.key("SourceEntity").start_object();
crate::json_ser::serialize_structure_crate_model_template_source_entity(
&mut object_158,
var_157,
)?;
object_158.finish();
}
if let Some(var_159) = &input.tags {
let mut array_160 = object.key("Tags").start_array();
for item_161 in var_159 {
{
#[allow(unused_mut)]
let mut object_162 = array_160.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_162, item_161)?;
object_162.finish();
}
}
array_160.finish();
}
if let Some(var_163) = &input.version_description {
object.key("VersionDescription").string(var_163.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_template_alias_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateTemplateAliasInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_164) = &input.template_version_number {
object.key("TemplateVersionNumber").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_164).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_theme_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateThemeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_165) = &input.base_theme_id {
object.key("BaseThemeId").string(var_165.as_str());
}
if let Some(var_166) = &input.configuration {
#[allow(unused_mut)]
let mut object_167 = object.key("Configuration").start_object();
crate::json_ser::serialize_structure_crate_model_theme_configuration(
&mut object_167,
var_166,
)?;
object_167.finish();
}
if let Some(var_168) = &input.name {
object.key("Name").string(var_168.as_str());
}
if let Some(var_169) = &input.permissions {
let mut array_170 = object.key("Permissions").start_array();
for item_171 in var_169 {
{
#[allow(unused_mut)]
let mut object_172 = array_170.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_permission(
&mut object_172,
item_171,
)?;
object_172.finish();
}
}
array_170.finish();
}
if let Some(var_173) = &input.tags {
let mut array_174 = object.key("Tags").start_array();
for item_175 in var_173 {
{
#[allow(unused_mut)]
let mut object_176 = array_174.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_176, item_175)?;
object_176.finish();
}
}
array_174.finish();
}
if let Some(var_177) = &input.version_description {
object.key("VersionDescription").string(var_177.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_theme_alias_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateThemeAliasInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_178) = &input.theme_version_number {
object.key("ThemeVersionNumber").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_178).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_generate_embed_url_for_anonymous_user_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GenerateEmbedUrlForAnonymousUserInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_179) = &input.allowed_domains {
let mut array_180 = object.key("AllowedDomains").start_array();
for item_181 in var_179 {
{
array_180.value().string(item_181.as_str());
}
}
array_180.finish();
}
if let Some(var_182) = &input.authorized_resource_arns {
let mut array_183 = object.key("AuthorizedResourceArns").start_array();
for item_184 in var_182 {
{
array_183.value().string(item_184.as_str());
}
}
array_183.finish();
}
if let Some(var_185) = &input.experience_configuration {
#[allow(unused_mut)]
let mut object_186 = object.key("ExperienceConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_anonymous_user_embedding_experience_configuration(&mut object_186, var_185)?;
object_186.finish();
}
if let Some(var_187) = &input.namespace {
object.key("Namespace").string(var_187.as_str());
}
if let Some(var_188) = &input.session_lifetime_in_minutes {
object.key("SessionLifetimeInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_188).into()),
);
}
if let Some(var_189) = &input.session_tags {
let mut array_190 = object.key("SessionTags").start_array();
for item_191 in var_189 {
{
#[allow(unused_mut)]
let mut object_192 = array_190.value().start_object();
crate::json_ser::serialize_structure_crate_model_session_tag(
&mut object_192,
item_191,
)?;
object_192.finish();
}
}
array_190.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_generate_embed_url_for_registered_user_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GenerateEmbedUrlForRegisteredUserInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_193) = &input.allowed_domains {
let mut array_194 = object.key("AllowedDomains").start_array();
for item_195 in var_193 {
{
array_194.value().string(item_195.as_str());
}
}
array_194.finish();
}
if let Some(var_196) = &input.experience_configuration {
#[allow(unused_mut)]
let mut object_197 = object.key("ExperienceConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_registered_user_embedding_experience_configuration(&mut object_197, var_196)?;
object_197.finish();
}
if let Some(var_198) = &input.session_lifetime_in_minutes {
object.key("SessionLifetimeInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_198).into()),
);
}
if let Some(var_199) = &input.user_arn {
object.key("UserArn").string(var_199.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_iam_policy_assignments_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListIamPolicyAssignmentsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_200) = &input.assignment_status {
object.key("AssignmentStatus").string(var_200.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_register_user_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterUserInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_201) = &input.custom_federation_provider_url {
object
.key("CustomFederationProviderUrl")
.string(var_201.as_str());
}
if let Some(var_202) = &input.custom_permissions_name {
object.key("CustomPermissionsName").string(var_202.as_str());
}
if let Some(var_203) = &input.email {
object.key("Email").string(var_203.as_str());
}
if let Some(var_204) = &input.external_login_federation_provider_type {
object
.key("ExternalLoginFederationProviderType")
.string(var_204.as_str());
}
if let Some(var_205) = &input.external_login_id {
object.key("ExternalLoginId").string(var_205.as_str());
}
if let Some(var_206) = &input.iam_arn {
object.key("IamArn").string(var_206.as_str());
}
if let Some(var_207) = &input.identity_type {
object.key("IdentityType").string(var_207.as_str());
}
if let Some(var_208) = &input.session_name {
object.key("SessionName").string(var_208.as_str());
}
if let Some(var_209) = &input.user_name {
object.key("UserName").string(var_209.as_str());
}
if let Some(var_210) = &input.user_role {
object.key("UserRole").string(var_210.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_search_analyses_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchAnalysesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_211) = &input.filters {
let mut array_212 = object.key("Filters").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_analysis_search_filter(
&mut object_214,
item_213,
)?;
object_214.finish();
}
}
array_212.finish();
}
if let Some(var_215) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_215).into()),
);
}
if let Some(var_216) = &input.next_token {
object.key("NextToken").string(var_216.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_search_dashboards_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchDashboardsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_217) = &input.filters {
let mut array_218 = object.key("Filters").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_dashboard_search_filter(
&mut object_220,
item_219,
)?;
object_220.finish();
}
}
array_218.finish();
}
if let Some(var_221) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_221).into()),
);
}
if let Some(var_222) = &input.next_token {
object.key("NextToken").string(var_222.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_search_data_sets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchDataSetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_223) = &input.filters {
let mut array_224 = object.key("Filters").start_array();
for item_225 in var_223 {
{
#[allow(unused_mut)]
let mut object_226 = array_224.value().start_object();
crate::json_ser::serialize_structure_crate_model_data_set_search_filter(
&mut object_226,
item_225,
)?;
object_226.finish();
}
}
array_224.finish();
}
if let Some(var_227) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_227).into()),
);
}
if let Some(var_228) = &input.next_token {
object.key("NextToken").string(var_228.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_search_data_sources_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchDataSourcesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_229) = &input.filters {
let mut array_230 = object.key("Filters").start_array();
for item_231 in var_229 {
{
#[allow(unused_mut)]
let mut object_232 = array_230.value().start_object();
crate::json_ser::serialize_structure_crate_model_data_source_search_filter(
&mut object_232,
item_231,
)?;
object_232.finish();
}
}
array_230.finish();
}
if let Some(var_233) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_233).into()),
);
}
if let Some(var_234) = &input.next_token {
object.key("NextToken").string(var_234.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_search_folders_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchFoldersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_235) = &input.filters {
let mut array_236 = object.key("Filters").start_array();
for item_237 in var_235 {
{
#[allow(unused_mut)]
let mut object_238 = array_236.value().start_object();
crate::json_ser::serialize_structure_crate_model_folder_search_filter(
&mut object_238,
item_237,
)?;
object_238.finish();
}
}
array_236.finish();
}
if let Some(var_239) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_239).into()),
);
}
if let Some(var_240) = &input.next_token {
object.key("NextToken").string(var_240.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_search_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchGroupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_241) = &input.filters {
let mut array_242 = object.key("Filters").start_array();
for item_243 in var_241 {
{
#[allow(unused_mut)]
let mut object_244 = array_242.value().start_object();
crate::json_ser::serialize_structure_crate_model_group_search_filter(
&mut object_244,
item_243,
)?;
object_244.finish();
}
}
array_242.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_245) = &input.tags {
let mut array_246 = object.key("Tags").start_array();
for item_247 in var_245 {
{
#[allow(unused_mut)]
let mut object_248 = array_246.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_248, item_247)?;
object_248.finish();
}
}
array_246.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_account_customization_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAccountCustomizationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_249) = &input.account_customization {
#[allow(unused_mut)]
let mut object_250 = object.key("AccountCustomization").start_object();
crate::json_ser::serialize_structure_crate_model_account_customization(
&mut object_250,
var_249,
)?;
object_250.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_account_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAccountSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_251) = &input.default_namespace {
object.key("DefaultNamespace").string(var_251.as_str());
}
if let Some(var_252) = &input.notification_email {
object.key("NotificationEmail").string(var_252.as_str());
}
if input.termination_protection_enabled {
object
.key("TerminationProtectionEnabled")
.boolean(input.termination_protection_enabled);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_analysis_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAnalysisInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_253) = &input.definition {
#[allow(unused_mut)]
let mut object_254 = object.key("Definition").start_object();
crate::json_ser::serialize_structure_crate_model_analysis_definition(
&mut object_254,
var_253,
)?;
object_254.finish();
}
if let Some(var_255) = &input.name {
object.key("Name").string(var_255.as_str());
}
if let Some(var_256) = &input.parameters {
#[allow(unused_mut)]
let mut object_257 = object.key("Parameters").start_object();
crate::json_ser::serialize_structure_crate_model_parameters(&mut object_257, var_256)?;
object_257.finish();
}
if let Some(var_258) = &input.source_entity {
#[allow(unused_mut)]
let mut object_259 = object.key("SourceEntity").start_object();
crate::json_ser::serialize_structure_crate_model_analysis_source_entity(
&mut object_259,
var_258,
)?;
object_259.finish();
}
if let Some(var_260) = &input.theme_arn {
object.key("ThemeArn").string(var_260.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_analysis_permissions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAnalysisPermissionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_261) = &input.grant_permissions {
let mut array_262 = object.key("GrantPermissions").start_array();
for item_263 in var_261 {
{
#[allow(unused_mut)]
let mut object_264 = array_262.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_permission(
&mut object_264,
item_263,
)?;
object_264.finish();
}
}
array_262.finish();
}
if let Some(var_265) = &input.revoke_permissions {
let mut array_266 = object.key("RevokePermissions").start_array();
for item_267 in var_265 {
{
#[allow(unused_mut)]
let mut object_268 = array_266.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_permission(
&mut object_268,
item_267,
)?;
object_268.finish();
}
}
array_266.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_dashboard_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDashboardInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_269) = &input.dashboard_publish_options {
#[allow(unused_mut)]
let mut object_270 = object.key("DashboardPublishOptions").start_object();
crate::json_ser::serialize_structure_crate_model_dashboard_publish_options(
&mut object_270,
var_269,
)?;
object_270.finish();
}
if let Some(var_271) = &input.definition {
#[allow(unused_mut)]
let mut object_272 = object.key("Definition").start_object();
crate::json_ser::serialize_structure_crate_model_dashboard_version_definition(
&mut object_272,
var_271,
)?;
object_272.finish();
}
if let Some(var_273) = &input.name {
object.key("Name").string(var_273.as_str());
}
if let Some(var_274) = &input.parameters {
#[allow(unused_mut)]
let mut object_275 = object.key("Parameters").start_object();
crate::json_ser::serialize_structure_crate_model_parameters(&mut object_275, var_274)?;
object_275.finish();
}
if let Some(var_276) = &input.source_entity {
#[allow(unused_mut)]
let mut object_277 = object.key("SourceEntity").start_object();
crate::json_ser::serialize_structure_crate_model_dashboard_source_entity(
&mut object_277,
var_276,
)?;
object_277.finish();
}
if let Some(var_278) = &input.theme_arn {
object.key("ThemeArn").string(var_278.as_str());
}
if let Some(var_279) = &input.version_description {
object.key("VersionDescription").string(var_279.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_dashboard_permissions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDashboardPermissionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_280) = &input.grant_link_permissions {
let mut array_281 = object.key("GrantLinkPermissions").start_array();
for item_282 in var_280 {
{
#[allow(unused_mut)]
let mut object_283 = array_281.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_permission(
&mut object_283,
item_282,
)?;
object_283.finish();
}
}
array_281.finish();
}
if let Some(var_284) = &input.grant_permissions {
let mut array_285 = object.key("GrantPermissions").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_resource_permission(
&mut object_287,
item_286,
)?;
object_287.finish();
}
}
array_285.finish();
}
if let Some(var_288) = &input.revoke_link_permissions {
let mut array_289 = object.key("RevokeLinkPermissions").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_resource_permission(
&mut object_291,
item_290,
)?;
object_291.finish();
}
}
array_289.finish();
}
if let Some(var_292) = &input.revoke_permissions {
let mut array_293 = object.key("RevokePermissions").start_array();
for item_294 in var_292 {
{
#[allow(unused_mut)]
let mut object_295 = array_293.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_permission(
&mut object_295,
item_294,
)?;
object_295.finish();
}
}
array_293.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_data_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDataSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_296) = &input.column_groups {
let mut array_297 = object.key("ColumnGroups").start_array();
for item_298 in var_296 {
{
#[allow(unused_mut)]
let mut object_299 = array_297.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_group(
&mut object_299,
item_298,
)?;
object_299.finish();
}
}
array_297.finish();
}
if let Some(var_300) = &input.column_level_permission_rules {
let mut array_301 = object.key("ColumnLevelPermissionRules").start_array();
for item_302 in var_300 {
{
#[allow(unused_mut)]
let mut object_303 = array_301.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_level_permission_rule(
&mut object_303,
item_302,
)?;
object_303.finish();
}
}
array_301.finish();
}
if let Some(var_304) = &input.data_set_usage_configuration {
#[allow(unused_mut)]
let mut object_305 = object.key("DataSetUsageConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_data_set_usage_configuration(
&mut object_305,
var_304,
)?;
object_305.finish();
}
if let Some(var_306) = &input.field_folders {
#[allow(unused_mut)]
let mut object_307 = object.key("FieldFolders").start_object();
for (key_308, value_309) in var_306 {
{
#[allow(unused_mut)]
let mut object_310 = object_307.key(key_308.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_field_folder(
&mut object_310,
value_309,
)?;
object_310.finish();
}
}
object_307.finish();
}
if let Some(var_311) = &input.import_mode {
object.key("ImportMode").string(var_311.as_str());
}
if let Some(var_312) = &input.logical_table_map {
#[allow(unused_mut)]
let mut object_313 = object.key("LogicalTableMap").start_object();
for (key_314, value_315) in var_312 {
{
#[allow(unused_mut)]
let mut object_316 = object_313.key(key_314.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_logical_table(
&mut object_316,
value_315,
)?;
object_316.finish();
}
}
object_313.finish();
}
if let Some(var_317) = &input.name {
object.key("Name").string(var_317.as_str());
}
if let Some(var_318) = &input.physical_table_map {
#[allow(unused_mut)]
let mut object_319 = object.key("PhysicalTableMap").start_object();
for (key_320, value_321) in var_318 {
{
#[allow(unused_mut)]
let mut object_322 = object_319.key(key_320.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_physical_table(
&mut object_322,
value_321,
)?;
object_322.finish();
}
}
object_319.finish();
}
if let Some(var_323) = &input.row_level_permission_data_set {
#[allow(unused_mut)]
let mut object_324 = object.key("RowLevelPermissionDataSet").start_object();
crate::json_ser::serialize_structure_crate_model_row_level_permission_data_set(
&mut object_324,
var_323,
)?;
object_324.finish();
}
if let Some(var_325) = &input.row_level_permission_tag_configuration {
#[allow(unused_mut)]
let mut object_326 = object
.key("RowLevelPermissionTagConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_row_level_permission_tag_configuration(
&mut object_326,
var_325,
)?;
object_326.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_data_set_permissions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDataSetPermissionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_327) = &input.grant_permissions {
let mut array_328 = object.key("GrantPermissions").start_array();
for item_329 in var_327 {
{
#[allow(unused_mut)]
let mut object_330 = array_328.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_permission(
&mut object_330,
item_329,
)?;
object_330.finish();
}
}
array_328.finish();
}
if let Some(var_331) = &input.revoke_permissions {
let mut array_332 = object.key("RevokePermissions").start_array();
for item_333 in var_331 {
{
#[allow(unused_mut)]
let mut object_334 = array_332.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_permission(
&mut object_334,
item_333,
)?;
object_334.finish();
}
}
array_332.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_data_source_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDataSourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_335) = &input.credentials {
#[allow(unused_mut)]
let mut object_336 = object.key("Credentials").start_object();
crate::json_ser::serialize_structure_crate_model_data_source_credentials(
&mut object_336,
var_335,
)?;
object_336.finish();
}
if let Some(var_337) = &input.data_source_parameters {
#[allow(unused_mut)]
let mut object_338 = object.key("DataSourceParameters").start_object();
crate::json_ser::serialize_union_crate_model_data_source_parameters(
&mut object_338,
var_337,
)?;
object_338.finish();
}
if let Some(var_339) = &input.name {
object.key("Name").string(var_339.as_str());
}
if let Some(var_340) = &input.ssl_properties {
#[allow(unused_mut)]
let mut object_341 = object.key("SslProperties").start_object();
crate::json_ser::serialize_structure_crate_model_ssl_properties(&mut object_341, var_340)?;
object_341.finish();
}
if let Some(var_342) = &input.vpc_connection_properties {
#[allow(unused_mut)]
let mut object_343 = object.key("VpcConnectionProperties").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_connection_properties(
&mut object_343,
var_342,
)?;
object_343.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_data_source_permissions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDataSourcePermissionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_344) = &input.grant_permissions {
let mut array_345 = object.key("GrantPermissions").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_resource_permission(
&mut object_347,
item_346,
)?;
object_347.finish();
}
}
array_345.finish();
}
if let Some(var_348) = &input.revoke_permissions {
let mut array_349 = object.key("RevokePermissions").start_array();
for item_350 in var_348 {
{
#[allow(unused_mut)]
let mut object_351 = array_349.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_permission(
&mut object_351,
item_350,
)?;
object_351.finish();
}
}
array_349.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_folder_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFolderInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_352) = &input.name {
object.key("Name").string(var_352.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_folder_permissions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFolderPermissionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_353) = &input.grant_permissions {
let mut array_354 = object.key("GrantPermissions").start_array();
for item_355 in var_353 {
{
#[allow(unused_mut)]
let mut object_356 = array_354.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_permission(
&mut object_356,
item_355,
)?;
object_356.finish();
}
}
array_354.finish();
}
if let Some(var_357) = &input.revoke_permissions {
let mut array_358 = object.key("RevokePermissions").start_array();
for item_359 in var_357 {
{
#[allow(unused_mut)]
let mut object_360 = array_358.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_permission(
&mut object_360,
item_359,
)?;
object_360.finish();
}
}
array_358.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_361) = &input.description {
object.key("Description").string(var_361.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_iam_policy_assignment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateIamPolicyAssignmentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_362) = &input.assignment_status {
object.key("AssignmentStatus").string(var_362.as_str());
}
if let Some(var_363) = &input.identities {
#[allow(unused_mut)]
let mut object_364 = object.key("Identities").start_object();
for (key_365, value_366) in var_363 {
{
let mut array_367 = object_364.key(key_365.as_str()).start_array();
for item_368 in value_366 {
{
array_367.value().string(item_368.as_str());
}
}
array_367.finish();
}
}
object_364.finish();
}
if let Some(var_369) = &input.policy_arn {
object.key("PolicyArn").string(var_369.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_ip_restriction_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateIpRestrictionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_370) = &input.enabled {
object.key("Enabled").boolean(*var_370);
}
if let Some(var_371) = &input.ip_restriction_rule_map {
#[allow(unused_mut)]
let mut object_372 = object.key("IpRestrictionRuleMap").start_object();
for (key_373, value_374) in var_371 {
{
object_372.key(key_373.as_str()).string(value_374.as_str());
}
}
object_372.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_public_sharing_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdatePublicSharingSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.public_sharing_enabled {
object
.key("PublicSharingEnabled")
.boolean(input.public_sharing_enabled);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_template_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateTemplateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_375) = &input.definition {
#[allow(unused_mut)]
let mut object_376 = object.key("Definition").start_object();
crate::json_ser::serialize_structure_crate_model_template_version_definition(
&mut object_376,
var_375,
)?;
object_376.finish();
}
if let Some(var_377) = &input.name {
object.key("Name").string(var_377.as_str());
}
if let Some(var_378) = &input.source_entity {
#[allow(unused_mut)]
let mut object_379 = object.key("SourceEntity").start_object();
crate::json_ser::serialize_structure_crate_model_template_source_entity(
&mut object_379,
var_378,
)?;
object_379.finish();
}
if let Some(var_380) = &input.version_description {
object.key("VersionDescription").string(var_380.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_template_alias_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateTemplateAliasInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_381) = &input.template_version_number {
object.key("TemplateVersionNumber").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_381).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_template_permissions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateTemplatePermissionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_382) = &input.grant_permissions {
let mut array_383 = object.key("GrantPermissions").start_array();
for item_384 in var_382 {
{
#[allow(unused_mut)]
let mut object_385 = array_383.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_permission(
&mut object_385,
item_384,
)?;
object_385.finish();
}
}
array_383.finish();
}
if let Some(var_386) = &input.revoke_permissions {
let mut array_387 = object.key("RevokePermissions").start_array();
for item_388 in var_386 {
{
#[allow(unused_mut)]
let mut object_389 = array_387.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_permission(
&mut object_389,
item_388,
)?;
object_389.finish();
}
}
array_387.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_theme_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateThemeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_390) = &input.base_theme_id {
object.key("BaseThemeId").string(var_390.as_str());
}
if let Some(var_391) = &input.configuration {
#[allow(unused_mut)]
let mut object_392 = object.key("Configuration").start_object();
crate::json_ser::serialize_structure_crate_model_theme_configuration(
&mut object_392,
var_391,
)?;
object_392.finish();
}
if let Some(var_393) = &input.name {
object.key("Name").string(var_393.as_str());
}
if let Some(var_394) = &input.version_description {
object.key("VersionDescription").string(var_394.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_theme_alias_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateThemeAliasInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_395) = &input.theme_version_number {
object.key("ThemeVersionNumber").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_395).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_theme_permissions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateThemePermissionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_396) = &input.grant_permissions {
let mut array_397 = object.key("GrantPermissions").start_array();
for item_398 in var_396 {
{
#[allow(unused_mut)]
let mut object_399 = array_397.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_permission(
&mut object_399,
item_398,
)?;
object_399.finish();
}
}
array_397.finish();
}
if let Some(var_400) = &input.revoke_permissions {
let mut array_401 = object.key("RevokePermissions").start_array();
for item_402 in var_400 {
{
#[allow(unused_mut)]
let mut object_403 = array_401.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_permission(
&mut object_403,
item_402,
)?;
object_403.finish();
}
}
array_401.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_user_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateUserInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_404) = &input.custom_federation_provider_url {
object
.key("CustomFederationProviderUrl")
.string(var_404.as_str());
}
if let Some(var_405) = &input.custom_permissions_name {
object.key("CustomPermissionsName").string(var_405.as_str());
}
if let Some(var_406) = &input.email {
object.key("Email").string(var_406.as_str());
}
if let Some(var_407) = &input.external_login_federation_provider_type {
object
.key("ExternalLoginFederationProviderType")
.string(var_407.as_str());
}
if let Some(var_408) = &input.external_login_id {
object.key("ExternalLoginId").string(var_408.as_str());
}
if let Some(var_409) = &input.role {
object.key("Role").string(var_409.as_str());
}
if input.unapply_custom_permissions {
object
.key("UnapplyCustomPermissions")
.boolean(input.unapply_custom_permissions);
}
Ok(())
}
pub fn serialize_structure_crate_model_account_customization(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AccountCustomization,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_410) = &input.default_theme {
object.key("DefaultTheme").string(var_410.as_str());
}
if let Some(var_411) = &input.default_email_customization_template {
object
.key("DefaultEmailCustomizationTemplate")
.string(var_411.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_412) = &input.key {
object.key("Key").string(var_412.as_str());
}
if let Some(var_413) = &input.value {
object.key("Value").string(var_413.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_analysis_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AnalysisDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_414) = &input.data_set_identifier_declarations {
let mut array_415 = object.key("DataSetIdentifierDeclarations").start_array();
for item_416 in var_414 {
{
#[allow(unused_mut)]
let mut object_417 = array_415.value().start_object();
crate::json_ser::serialize_structure_crate_model_data_set_identifier_declaration(
&mut object_417,
item_416,
)?;
object_417.finish();
}
}
array_415.finish();
}
if let Some(var_418) = &input.sheets {
let mut array_419 = object.key("Sheets").start_array();
for item_420 in var_418 {
{
#[allow(unused_mut)]
let mut object_421 = array_419.value().start_object();
crate::json_ser::serialize_structure_crate_model_sheet_definition(
&mut object_421,
item_420,
)?;
object_421.finish();
}
}
array_419.finish();
}
if let Some(var_422) = &input.calculated_fields {
let mut array_423 = object.key("CalculatedFields").start_array();
for item_424 in var_422 {
{
#[allow(unused_mut)]
let mut object_425 = array_423.value().start_object();
crate::json_ser::serialize_structure_crate_model_calculated_field(
&mut object_425,
item_424,
)?;
object_425.finish();
}
}
array_423.finish();
}
if let Some(var_426) = &input.parameter_declarations {
let mut array_427 = object.key("ParameterDeclarations").start_array();
for item_428 in var_426 {
{
#[allow(unused_mut)]
let mut object_429 = array_427.value().start_object();
crate::json_ser::serialize_structure_crate_model_parameter_declaration(
&mut object_429,
item_428,
)?;
object_429.finish();
}
}
array_427.finish();
}
if let Some(var_430) = &input.filter_groups {
let mut array_431 = object.key("FilterGroups").start_array();
for item_432 in var_430 {
{
#[allow(unused_mut)]
let mut object_433 = array_431.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_group(
&mut object_433,
item_432,
)?;
object_433.finish();
}
}
array_431.finish();
}
if let Some(var_434) = &input.column_configurations {
let mut array_435 = object.key("ColumnConfigurations").start_array();
for item_436 in var_434 {
{
#[allow(unused_mut)]
let mut object_437 = array_435.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_configuration(
&mut object_437,
item_436,
)?;
object_437.finish();
}
}
array_435.finish();
}
if let Some(var_438) = &input.analysis_defaults {
#[allow(unused_mut)]
let mut object_439 = object.key("AnalysisDefaults").start_object();
crate::json_ser::serialize_structure_crate_model_analysis_defaults(
&mut object_439,
var_438,
)?;
object_439.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Parameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_440) = &input.string_parameters {
let mut array_441 = object.key("StringParameters").start_array();
for item_442 in var_440 {
{
#[allow(unused_mut)]
let mut object_443 = array_441.value().start_object();
crate::json_ser::serialize_structure_crate_model_string_parameter(
&mut object_443,
item_442,
)?;
object_443.finish();
}
}
array_441.finish();
}
if let Some(var_444) = &input.integer_parameters {
let mut array_445 = object.key("IntegerParameters").start_array();
for item_446 in var_444 {
{
#[allow(unused_mut)]
let mut object_447 = array_445.value().start_object();
crate::json_ser::serialize_structure_crate_model_integer_parameter(
&mut object_447,
item_446,
)?;
object_447.finish();
}
}
array_445.finish();
}
if let Some(var_448) = &input.decimal_parameters {
let mut array_449 = object.key("DecimalParameters").start_array();
for item_450 in var_448 {
{
#[allow(unused_mut)]
let mut object_451 = array_449.value().start_object();
crate::json_ser::serialize_structure_crate_model_decimal_parameter(
&mut object_451,
item_450,
)?;
object_451.finish();
}
}
array_449.finish();
}
if let Some(var_452) = &input.date_time_parameters {
let mut array_453 = object.key("DateTimeParameters").start_array();
for item_454 in var_452 {
{
#[allow(unused_mut)]
let mut object_455 = array_453.value().start_object();
crate::json_ser::serialize_structure_crate_model_date_time_parameter(
&mut object_455,
item_454,
)?;
object_455.finish();
}
}
array_453.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_permission(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourcePermission,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_456) = &input.principal {
object.key("Principal").string(var_456.as_str());
}
if let Some(var_457) = &input.actions {
let mut array_458 = object.key("Actions").start_array();
for item_459 in var_457 {
{
array_458.value().string(item_459.as_str());
}
}
array_458.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_analysis_source_entity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AnalysisSourceEntity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_460) = &input.source_template {
#[allow(unused_mut)]
let mut object_461 = object.key("SourceTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_analysis_source_template(
&mut object_461,
var_460,
)?;
object_461.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_dashboard_publish_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DashboardPublishOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_462) = &input.ad_hoc_filtering_option {
#[allow(unused_mut)]
let mut object_463 = object.key("AdHocFilteringOption").start_object();
crate::json_ser::serialize_structure_crate_model_ad_hoc_filtering_option(
&mut object_463,
var_462,
)?;
object_463.finish();
}
if let Some(var_464) = &input.export_to_csv_option {
#[allow(unused_mut)]
let mut object_465 = object.key("ExportToCSVOption").start_object();
crate::json_ser::serialize_structure_crate_model_export_to_csv_option(
&mut object_465,
var_464,
)?;
object_465.finish();
}
if let Some(var_466) = &input.sheet_controls_option {
#[allow(unused_mut)]
let mut object_467 = object.key("SheetControlsOption").start_object();
crate::json_ser::serialize_structure_crate_model_sheet_controls_option(
&mut object_467,
var_466,
)?;
object_467.finish();
}
if let Some(var_468) = &input.visual_publish_options {
#[allow(unused_mut)]
let mut object_469 = object.key("VisualPublishOptions").start_object();
crate::json_ser::serialize_structure_crate_model_dashboard_visual_publish_options(
&mut object_469,
var_468,
)?;
object_469.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_dashboard_version_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DashboardVersionDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_470) = &input.data_set_identifier_declarations {
let mut array_471 = object.key("DataSetIdentifierDeclarations").start_array();
for item_472 in var_470 {
{
#[allow(unused_mut)]
let mut object_473 = array_471.value().start_object();
crate::json_ser::serialize_structure_crate_model_data_set_identifier_declaration(
&mut object_473,
item_472,
)?;
object_473.finish();
}
}
array_471.finish();
}
if let Some(var_474) = &input.sheets {
let mut array_475 = object.key("Sheets").start_array();
for item_476 in var_474 {
{
#[allow(unused_mut)]
let mut object_477 = array_475.value().start_object();
crate::json_ser::serialize_structure_crate_model_sheet_definition(
&mut object_477,
item_476,
)?;
object_477.finish();
}
}
array_475.finish();
}
if let Some(var_478) = &input.calculated_fields {
let mut array_479 = object.key("CalculatedFields").start_array();
for item_480 in var_478 {
{
#[allow(unused_mut)]
let mut object_481 = array_479.value().start_object();
crate::json_ser::serialize_structure_crate_model_calculated_field(
&mut object_481,
item_480,
)?;
object_481.finish();
}
}
array_479.finish();
}
if let Some(var_482) = &input.parameter_declarations {
let mut array_483 = object.key("ParameterDeclarations").start_array();
for item_484 in var_482 {
{
#[allow(unused_mut)]
let mut object_485 = array_483.value().start_object();
crate::json_ser::serialize_structure_crate_model_parameter_declaration(
&mut object_485,
item_484,
)?;
object_485.finish();
}
}
array_483.finish();
}
if let Some(var_486) = &input.filter_groups {
let mut array_487 = object.key("FilterGroups").start_array();
for item_488 in var_486 {
{
#[allow(unused_mut)]
let mut object_489 = array_487.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_group(
&mut object_489,
item_488,
)?;
object_489.finish();
}
}
array_487.finish();
}
if let Some(var_490) = &input.column_configurations {
let mut array_491 = object.key("ColumnConfigurations").start_array();
for item_492 in var_490 {
{
#[allow(unused_mut)]
let mut object_493 = array_491.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_configuration(
&mut object_493,
item_492,
)?;
object_493.finish();
}
}
array_491.finish();
}
if let Some(var_494) = &input.analysis_defaults {
#[allow(unused_mut)]
let mut object_495 = object.key("AnalysisDefaults").start_object();
crate::json_ser::serialize_structure_crate_model_analysis_defaults(
&mut object_495,
var_494,
)?;
object_495.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_dashboard_source_entity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DashboardSourceEntity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_496) = &input.source_template {
#[allow(unused_mut)]
let mut object_497 = object.key("SourceTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_dashboard_source_template(
&mut object_497,
var_496,
)?;
object_497.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_column_group(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ColumnGroup,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_498) = &input.geo_spatial_column_group {
#[allow(unused_mut)]
let mut object_499 = object.key("GeoSpatialColumnGroup").start_object();
crate::json_ser::serialize_structure_crate_model_geo_spatial_column_group(
&mut object_499,
var_498,
)?;
object_499.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_column_level_permission_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ColumnLevelPermissionRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_500) = &input.principals {
let mut array_501 = object.key("Principals").start_array();
for item_502 in var_500 {
{
array_501.value().string(item_502.as_str());
}
}
array_501.finish();
}
if let Some(var_503) = &input.column_names {
let mut array_504 = object.key("ColumnNames").start_array();
for item_505 in var_503 {
{
array_504.value().string(item_505.as_str());
}
}
array_504.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_data_set_usage_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataSetUsageConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.disable_use_as_direct_query_source {
object
.key("DisableUseAsDirectQuerySource")
.boolean(input.disable_use_as_direct_query_source);
}
if input.disable_use_as_imported_source {
object
.key("DisableUseAsImportedSource")
.boolean(input.disable_use_as_imported_source);
}
Ok(())
}
pub fn serialize_structure_crate_model_field_folder(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FieldFolder,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_506) = &input.description {
object.key("description").string(var_506.as_str());
}
if let Some(var_507) = &input.columns {
let mut array_508 = object.key("columns").start_array();
for item_509 in var_507 {
{
array_508.value().string(item_509.as_str());
}
}
array_508.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_logical_table(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LogicalTable,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_510) = &input.alias {
object.key("Alias").string(var_510.as_str());
}
if let Some(var_511) = &input.data_transforms {
let mut array_512 = object.key("DataTransforms").start_array();
for item_513 in var_511 {
{
#[allow(unused_mut)]
let mut object_514 = array_512.value().start_object();
crate::json_ser::serialize_union_crate_model_transform_operation(
&mut object_514,
item_513,
)?;
object_514.finish();
}
}
array_512.finish();
}
if let Some(var_515) = &input.source {
#[allow(unused_mut)]
let mut object_516 = object.key("Source").start_object();
crate::json_ser::serialize_structure_crate_model_logical_table_source(
&mut object_516,
var_515,
)?;
object_516.finish();
}
Ok(())
}
pub fn serialize_union_crate_model_physical_table(
object_93: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PhysicalTable,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::PhysicalTable::RelationalTable(inner) => {
#[allow(unused_mut)]
let mut object_517 = object_93.key("RelationalTable").start_object();
crate::json_ser::serialize_structure_crate_model_relational_table(
&mut object_517,
inner,
)?;
object_517.finish();
}
crate::model::PhysicalTable::CustomSql(inner) => {
#[allow(unused_mut)]
let mut object_518 = object_93.key("CustomSql").start_object();
crate::json_ser::serialize_structure_crate_model_custom_sql(&mut object_518, inner)?;
object_518.finish();
}
crate::model::PhysicalTable::S3Source(inner) => {
#[allow(unused_mut)]
let mut object_519 = object_93.key("S3Source").start_object();
crate::json_ser::serialize_structure_crate_model_s3_source(&mut object_519, inner)?;
object_519.finish();
}
crate::model::PhysicalTable::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"PhysicalTable",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_row_level_permission_data_set(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RowLevelPermissionDataSet,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_520) = &input.namespace {
object.key("Namespace").string(var_520.as_str());
}
if let Some(var_521) = &input.arn {
object.key("Arn").string(var_521.as_str());
}
if let Some(var_522) = &input.permission_policy {
object.key("PermissionPolicy").string(var_522.as_str());
}
if let Some(var_523) = &input.format_version {
object.key("FormatVersion").string(var_523.as_str());
}
if let Some(var_524) = &input.status {
object.key("Status").string(var_524.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_row_level_permission_tag_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RowLevelPermissionTagConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_525) = &input.status {
object.key("Status").string(var_525.as_str());
}
if let Some(var_526) = &input.tag_rules {
let mut array_527 = object.key("TagRules").start_array();
for item_528 in var_526 {
{
#[allow(unused_mut)]
let mut object_529 = array_527.value().start_object();
crate::json_ser::serialize_structure_crate_model_row_level_permission_tag_rule(
&mut object_529,
item_528,
)?;
object_529.finish();
}
}
array_527.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_data_source_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataSourceCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_530) = &input.credential_pair {
#[allow(unused_mut)]
let mut object_531 = object.key("CredentialPair").start_object();
crate::json_ser::serialize_structure_crate_model_credential_pair(&mut object_531, var_530)?;
object_531.finish();
}
if let Some(var_532) = &input.copy_source_arn {
object.key("CopySourceArn").string(var_532.as_str());
}
if let Some(var_533) = &input.secret_arn {
object.key("SecretArn").string(var_533.as_str());
}
Ok(())
}
pub fn serialize_union_crate_model_data_source_parameters(
object_106: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataSourceParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::DataSourceParameters::AmazonElasticsearchParameters(inner) => {
#[allow(unused_mut)]
let mut object_534 = object_106
.key("AmazonElasticsearchParameters")
.start_object();
crate::json_ser::serialize_structure_crate_model_amazon_elasticsearch_parameters(
&mut object_534,
inner,
)?;
object_534.finish();
}
crate::model::DataSourceParameters::AthenaParameters(inner) => {
#[allow(unused_mut)]
let mut object_535 = object_106.key("AthenaParameters").start_object();
crate::json_ser::serialize_structure_crate_model_athena_parameters(
&mut object_535,
inner,
)?;
object_535.finish();
}
crate::model::DataSourceParameters::AuroraParameters(inner) => {
#[allow(unused_mut)]
let mut object_536 = object_106.key("AuroraParameters").start_object();
crate::json_ser::serialize_structure_crate_model_aurora_parameters(
&mut object_536,
inner,
)?;
object_536.finish();
}
crate::model::DataSourceParameters::AuroraPostgreSqlParameters(inner) => {
#[allow(unused_mut)]
let mut object_537 = object_106.key("AuroraPostgreSqlParameters").start_object();
crate::json_ser::serialize_structure_crate_model_aurora_postgre_sql_parameters(
&mut object_537,
inner,
)?;
object_537.finish();
}
crate::model::DataSourceParameters::AwsIotAnalyticsParameters(inner) => {
#[allow(unused_mut)]
let mut object_538 = object_106.key("AwsIotAnalyticsParameters").start_object();
crate::json_ser::serialize_structure_crate_model_aws_iot_analytics_parameters(
&mut object_538,
inner,
)?;
object_538.finish();
}
crate::model::DataSourceParameters::JiraParameters(inner) => {
#[allow(unused_mut)]
let mut object_539 = object_106.key("JiraParameters").start_object();
crate::json_ser::serialize_structure_crate_model_jira_parameters(
&mut object_539,
inner,
)?;
object_539.finish();
}
crate::model::DataSourceParameters::MariaDbParameters(inner) => {
#[allow(unused_mut)]
let mut object_540 = object_106.key("MariaDbParameters").start_object();
crate::json_ser::serialize_structure_crate_model_maria_db_parameters(
&mut object_540,
inner,
)?;
object_540.finish();
}
crate::model::DataSourceParameters::MySqlParameters(inner) => {
#[allow(unused_mut)]
let mut object_541 = object_106.key("MySqlParameters").start_object();
crate::json_ser::serialize_structure_crate_model_my_sql_parameters(
&mut object_541,
inner,
)?;
object_541.finish();
}
crate::model::DataSourceParameters::OracleParameters(inner) => {
#[allow(unused_mut)]
let mut object_542 = object_106.key("OracleParameters").start_object();
crate::json_ser::serialize_structure_crate_model_oracle_parameters(
&mut object_542,
inner,
)?;
object_542.finish();
}
crate::model::DataSourceParameters::PostgreSqlParameters(inner) => {
#[allow(unused_mut)]
let mut object_543 = object_106.key("PostgreSqlParameters").start_object();
crate::json_ser::serialize_structure_crate_model_postgre_sql_parameters(
&mut object_543,
inner,
)?;
object_543.finish();
}
crate::model::DataSourceParameters::PrestoParameters(inner) => {
#[allow(unused_mut)]
let mut object_544 = object_106.key("PrestoParameters").start_object();
crate::json_ser::serialize_structure_crate_model_presto_parameters(
&mut object_544,
inner,
)?;
object_544.finish();
}
crate::model::DataSourceParameters::RdsParameters(inner) => {
#[allow(unused_mut)]
let mut object_545 = object_106.key("RdsParameters").start_object();
crate::json_ser::serialize_structure_crate_model_rds_parameters(
&mut object_545,
inner,
)?;
object_545.finish();
}
crate::model::DataSourceParameters::RedshiftParameters(inner) => {
#[allow(unused_mut)]
let mut object_546 = object_106.key("RedshiftParameters").start_object();
crate::json_ser::serialize_structure_crate_model_redshift_parameters(
&mut object_546,
inner,
)?;
object_546.finish();
}
crate::model::DataSourceParameters::S3Parameters(inner) => {
#[allow(unused_mut)]
let mut object_547 = object_106.key("S3Parameters").start_object();
crate::json_ser::serialize_structure_crate_model_s3_parameters(&mut object_547, inner)?;
object_547.finish();
}
crate::model::DataSourceParameters::ServiceNowParameters(inner) => {
#[allow(unused_mut)]
let mut object_548 = object_106.key("ServiceNowParameters").start_object();
crate::json_ser::serialize_structure_crate_model_service_now_parameters(
&mut object_548,
inner,
)?;
object_548.finish();
}
crate::model::DataSourceParameters::SnowflakeParameters(inner) => {
#[allow(unused_mut)]
let mut object_549 = object_106.key("SnowflakeParameters").start_object();
crate::json_ser::serialize_structure_crate_model_snowflake_parameters(
&mut object_549,
inner,
)?;
object_549.finish();
}
crate::model::DataSourceParameters::SparkParameters(inner) => {
#[allow(unused_mut)]
let mut object_550 = object_106.key("SparkParameters").start_object();
crate::json_ser::serialize_structure_crate_model_spark_parameters(
&mut object_550,
inner,
)?;
object_550.finish();
}
crate::model::DataSourceParameters::SqlServerParameters(inner) => {
#[allow(unused_mut)]
let mut object_551 = object_106.key("SqlServerParameters").start_object();
crate::json_ser::serialize_structure_crate_model_sql_server_parameters(
&mut object_551,
inner,
)?;
object_551.finish();
}
crate::model::DataSourceParameters::TeradataParameters(inner) => {
#[allow(unused_mut)]
let mut object_552 = object_106.key("TeradataParameters").start_object();
crate::json_ser::serialize_structure_crate_model_teradata_parameters(
&mut object_552,
inner,
)?;
object_552.finish();
}
crate::model::DataSourceParameters::TwitterParameters(inner) => {
#[allow(unused_mut)]
let mut object_553 = object_106.key("TwitterParameters").start_object();
crate::json_ser::serialize_structure_crate_model_twitter_parameters(
&mut object_553,
inner,
)?;
object_553.finish();
}
crate::model::DataSourceParameters::AmazonOpenSearchParameters(inner) => {
#[allow(unused_mut)]
let mut object_554 = object_106.key("AmazonOpenSearchParameters").start_object();
crate::json_ser::serialize_structure_crate_model_amazon_open_search_parameters(
&mut object_554,
inner,
)?;
object_554.finish();
}
crate::model::DataSourceParameters::ExasolParameters(inner) => {
#[allow(unused_mut)]
let mut object_555 = object_106.key("ExasolParameters").start_object();
crate::json_ser::serialize_structure_crate_model_exasol_parameters(
&mut object_555,
inner,
)?;
object_555.finish();
}
crate::model::DataSourceParameters::DatabricksParameters(inner) => {
#[allow(unused_mut)]
let mut object_556 = object_106.key("DatabricksParameters").start_object();
crate::json_ser::serialize_structure_crate_model_databricks_parameters(
&mut object_556,
inner,
)?;
object_556.finish();
}
crate::model::DataSourceParameters::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"DataSourceParameters",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_ssl_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SslProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.disable_ssl {
object.key("DisableSsl").boolean(input.disable_ssl);
}
Ok(())
}
pub fn serialize_structure_crate_model_vpc_connection_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VpcConnectionProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_557) = &input.vpc_connection_arn {
object.key("VpcConnectionArn").string(var_557.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_template_version_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TemplateVersionDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_558) = &input.data_set_configurations {
let mut array_559 = object.key("DataSetConfigurations").start_array();
for item_560 in var_558 {
{
#[allow(unused_mut)]
let mut object_561 = array_559.value().start_object();
crate::json_ser::serialize_structure_crate_model_data_set_configuration(
&mut object_561,
item_560,
)?;
object_561.finish();
}
}
array_559.finish();
}
if let Some(var_562) = &input.sheets {
let mut array_563 = object.key("Sheets").start_array();
for item_564 in var_562 {
{
#[allow(unused_mut)]
let mut object_565 = array_563.value().start_object();
crate::json_ser::serialize_structure_crate_model_sheet_definition(
&mut object_565,
item_564,
)?;
object_565.finish();
}
}
array_563.finish();
}
if let Some(var_566) = &input.calculated_fields {
let mut array_567 = object.key("CalculatedFields").start_array();
for item_568 in var_566 {
{
#[allow(unused_mut)]
let mut object_569 = array_567.value().start_object();
crate::json_ser::serialize_structure_crate_model_calculated_field(
&mut object_569,
item_568,
)?;
object_569.finish();
}
}
array_567.finish();
}
if let Some(var_570) = &input.parameter_declarations {
let mut array_571 = object.key("ParameterDeclarations").start_array();
for item_572 in var_570 {
{
#[allow(unused_mut)]
let mut object_573 = array_571.value().start_object();
crate::json_ser::serialize_structure_crate_model_parameter_declaration(
&mut object_573,
item_572,
)?;
object_573.finish();
}
}
array_571.finish();
}
if let Some(var_574) = &input.filter_groups {
let mut array_575 = object.key("FilterGroups").start_array();
for item_576 in var_574 {
{
#[allow(unused_mut)]
let mut object_577 = array_575.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_group(
&mut object_577,
item_576,
)?;
object_577.finish();
}
}
array_575.finish();
}
if let Some(var_578) = &input.column_configurations {
let mut array_579 = object.key("ColumnConfigurations").start_array();
for item_580 in var_578 {
{
#[allow(unused_mut)]
let mut object_581 = array_579.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_configuration(
&mut object_581,
item_580,
)?;
object_581.finish();
}
}
array_579.finish();
}
if let Some(var_582) = &input.analysis_defaults {
#[allow(unused_mut)]
let mut object_583 = object.key("AnalysisDefaults").start_object();
crate::json_ser::serialize_structure_crate_model_analysis_defaults(
&mut object_583,
var_582,
)?;
object_583.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_template_source_entity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TemplateSourceEntity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_584) = &input.source_analysis {
#[allow(unused_mut)]
let mut object_585 = object.key("SourceAnalysis").start_object();
crate::json_ser::serialize_structure_crate_model_template_source_analysis(
&mut object_585,
var_584,
)?;
object_585.finish();
}
if let Some(var_586) = &input.source_template {
#[allow(unused_mut)]
let mut object_587 = object.key("SourceTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_template_source_template(
&mut object_587,
var_586,
)?;
object_587.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_theme_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ThemeConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_588) = &input.data_color_palette {
#[allow(unused_mut)]
let mut object_589 = object.key("DataColorPalette").start_object();
crate::json_ser::serialize_structure_crate_model_data_color_palette(
&mut object_589,
var_588,
)?;
object_589.finish();
}
if let Some(var_590) = &input.ui_color_palette {
#[allow(unused_mut)]
let mut object_591 = object.key("UIColorPalette").start_object();
crate::json_ser::serialize_structure_crate_model_ui_color_palette(
&mut object_591,
var_590,
)?;
object_591.finish();
}
if let Some(var_592) = &input.sheet {
#[allow(unused_mut)]
let mut object_593 = object.key("Sheet").start_object();
crate::json_ser::serialize_structure_crate_model_sheet_style(&mut object_593, var_592)?;
object_593.finish();
}
if let Some(var_594) = &input.typography {
#[allow(unused_mut)]
let mut object_595 = object.key("Typography").start_object();
crate::json_ser::serialize_structure_crate_model_typography(&mut object_595, var_594)?;
object_595.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_anonymous_user_embedding_experience_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AnonymousUserEmbeddingExperienceConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_596) = &input.dashboard {
#[allow(unused_mut)]
let mut object_597 = object.key("Dashboard").start_object();
crate::json_ser::serialize_structure_crate_model_anonymous_user_dashboard_embedding_configuration(&mut object_597, var_596)?;
object_597.finish();
}
if let Some(var_598) = &input.dashboard_visual {
#[allow(unused_mut)]
let mut object_599 = object.key("DashboardVisual").start_object();
crate::json_ser::serialize_structure_crate_model_anonymous_user_dashboard_visual_embedding_configuration(&mut object_599, var_598)?;
object_599.finish();
}
if let Some(var_600) = &input.q_search_bar {
#[allow(unused_mut)]
let mut object_601 = object.key("QSearchBar").start_object();
crate::json_ser::serialize_structure_crate_model_anonymous_user_q_search_bar_embedding_configuration(&mut object_601, var_600)?;
object_601.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_session_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SessionTag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_602) = &input.key {
object.key("Key").string(var_602.as_str());
}
if let Some(var_603) = &input.value {
object.key("Value").string(var_603.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_registered_user_embedding_experience_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RegisteredUserEmbeddingExperienceConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_604) = &input.dashboard {
#[allow(unused_mut)]
let mut object_605 = object.key("Dashboard").start_object();
crate::json_ser::serialize_structure_crate_model_registered_user_dashboard_embedding_configuration(&mut object_605, var_604)?;
object_605.finish();
}
if let Some(var_606) = &input.quick_sight_console {
#[allow(unused_mut)]
let mut object_607 = object.key("QuickSightConsole").start_object();
crate::json_ser::serialize_structure_crate_model_registered_user_quick_sight_console_embedding_configuration(&mut object_607, var_606)?;
object_607.finish();
}
if let Some(var_608) = &input.q_search_bar {
#[allow(unused_mut)]
let mut object_609 = object.key("QSearchBar").start_object();
crate::json_ser::serialize_structure_crate_model_registered_user_q_search_bar_embedding_configuration(&mut object_609, var_608)?;
object_609.finish();
}
if let Some(var_610) = &input.dashboard_visual {
#[allow(unused_mut)]
let mut object_611 = object.key("DashboardVisual").start_object();
crate::json_ser::serialize_structure_crate_model_registered_user_dashboard_visual_embedding_configuration(&mut object_611, var_610)?;
object_611.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_analysis_search_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AnalysisSearchFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_612) = &input.operator {
object.key("Operator").string(var_612.as_str());
}
if let Some(var_613) = &input.name {
object.key("Name").string(var_613.as_str());
}
if let Some(var_614) = &input.value {
object.key("Value").string(var_614.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_dashboard_search_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DashboardSearchFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_615) = &input.operator {
object.key("Operator").string(var_615.as_str());
}
if let Some(var_616) = &input.name {
object.key("Name").string(var_616.as_str());
}
if let Some(var_617) = &input.value {
object.key("Value").string(var_617.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_data_set_search_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataSetSearchFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_618) = &input.operator {
object.key("Operator").string(var_618.as_str());
}
if let Some(var_619) = &input.name {
object.key("Name").string(var_619.as_str());
}
if let Some(var_620) = &input.value {
object.key("Value").string(var_620.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_data_source_search_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataSourceSearchFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_621) = &input.operator {
object.key("Operator").string(var_621.as_str());
}
if let Some(var_622) = &input.name {
object.key("Name").string(var_622.as_str());
}
if let Some(var_623) = &input.value {
object.key("Value").string(var_623.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_folder_search_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FolderSearchFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_624) = &input.operator {
object.key("Operator").string(var_624.as_str());
}
if let Some(var_625) = &input.name {
object.key("Name").string(var_625.as_str());
}
if let Some(var_626) = &input.value {
object.key("Value").string(var_626.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_group_search_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GroupSearchFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_627) = &input.operator {
object.key("Operator").string(var_627.as_str());
}
if let Some(var_628) = &input.name {
object.key("Name").string(var_628.as_str());
}
if let Some(var_629) = &input.value {
object.key("Value").string(var_629.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_data_set_identifier_declaration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataSetIdentifierDeclaration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_630) = &input.identifier {
object.key("Identifier").string(var_630.as_str());
}
if let Some(var_631) = &input.data_set_arn {
object.key("DataSetArn").string(var_631.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sheet_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SheetDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_632) = &input.sheet_id {
object.key("SheetId").string(var_632.as_str());
}
if let Some(var_633) = &input.title {
object.key("Title").string(var_633.as_str());
}
if let Some(var_634) = &input.description {
object.key("Description").string(var_634.as_str());
}
if let Some(var_635) = &input.name {
object.key("Name").string(var_635.as_str());
}
if let Some(var_636) = &input.parameter_controls {
let mut array_637 = object.key("ParameterControls").start_array();
for item_638 in var_636 {
{
#[allow(unused_mut)]
let mut object_639 = array_637.value().start_object();
crate::json_ser::serialize_structure_crate_model_parameter_control(
&mut object_639,
item_638,
)?;
object_639.finish();
}
}
array_637.finish();
}
if let Some(var_640) = &input.filter_controls {
let mut array_641 = object.key("FilterControls").start_array();
for item_642 in var_640 {
{
#[allow(unused_mut)]
let mut object_643 = array_641.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_control(
&mut object_643,
item_642,
)?;
object_643.finish();
}
}
array_641.finish();
}
if let Some(var_644) = &input.visuals {
let mut array_645 = object.key("Visuals").start_array();
for item_646 in var_644 {
{
#[allow(unused_mut)]
let mut object_647 = array_645.value().start_object();
crate::json_ser::serialize_structure_crate_model_visual(&mut object_647, item_646)?;
object_647.finish();
}
}
array_645.finish();
}
if let Some(var_648) = &input.text_boxes {
let mut array_649 = object.key("TextBoxes").start_array();
for item_650 in var_648 {
{
#[allow(unused_mut)]
let mut object_651 = array_649.value().start_object();
crate::json_ser::serialize_structure_crate_model_sheet_text_box(
&mut object_651,
item_650,
)?;
object_651.finish();
}
}
array_649.finish();
}
if let Some(var_652) = &input.layouts {
let mut array_653 = object.key("Layouts").start_array();
for item_654 in var_652 {
{
#[allow(unused_mut)]
let mut object_655 = array_653.value().start_object();
crate::json_ser::serialize_structure_crate_model_layout(&mut object_655, item_654)?;
object_655.finish();
}
}
array_653.finish();
}
if let Some(var_656) = &input.sheet_control_layouts {
let mut array_657 = object.key("SheetControlLayouts").start_array();
for item_658 in var_656 {
{
#[allow(unused_mut)]
let mut object_659 = array_657.value().start_object();
crate::json_ser::serialize_structure_crate_model_sheet_control_layout(
&mut object_659,
item_658,
)?;
object_659.finish();
}
}
array_657.finish();
}
if let Some(var_660) = &input.content_type {
object.key("ContentType").string(var_660.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_calculated_field(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CalculatedField,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_661) = &input.data_set_identifier {
object.key("DataSetIdentifier").string(var_661.as_str());
}
if let Some(var_662) = &input.name {
object.key("Name").string(var_662.as_str());
}
if let Some(var_663) = &input.expression {
object.key("Expression").string(var_663.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_parameter_declaration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParameterDeclaration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_664) = &input.string_parameter_declaration {
#[allow(unused_mut)]
let mut object_665 = object.key("StringParameterDeclaration").start_object();
crate::json_ser::serialize_structure_crate_model_string_parameter_declaration(
&mut object_665,
var_664,
)?;
object_665.finish();
}
if let Some(var_666) = &input.decimal_parameter_declaration {
#[allow(unused_mut)]
let mut object_667 = object.key("DecimalParameterDeclaration").start_object();
crate::json_ser::serialize_structure_crate_model_decimal_parameter_declaration(
&mut object_667,
var_666,
)?;
object_667.finish();
}
if let Some(var_668) = &input.integer_parameter_declaration {
#[allow(unused_mut)]
let mut object_669 = object.key("IntegerParameterDeclaration").start_object();
crate::json_ser::serialize_structure_crate_model_integer_parameter_declaration(
&mut object_669,
var_668,
)?;
object_669.finish();
}
if let Some(var_670) = &input.date_time_parameter_declaration {
#[allow(unused_mut)]
let mut object_671 = object.key("DateTimeParameterDeclaration").start_object();
crate::json_ser::serialize_structure_crate_model_date_time_parameter_declaration(
&mut object_671,
var_670,
)?;
object_671.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_group(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterGroup,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_672) = &input.filter_group_id {
object.key("FilterGroupId").string(var_672.as_str());
}
if let Some(var_673) = &input.filters {
let mut array_674 = object.key("Filters").start_array();
for item_675 in var_673 {
{
#[allow(unused_mut)]
let mut object_676 = array_674.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_676, item_675)?;
object_676.finish();
}
}
array_674.finish();
}
if let Some(var_677) = &input.scope_configuration {
#[allow(unused_mut)]
let mut object_678 = object.key("ScopeConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_filter_scope_configuration(
&mut object_678,
var_677,
)?;
object_678.finish();
}
if let Some(var_679) = &input.status {
object.key("Status").string(var_679.as_str());
}
if let Some(var_680) = &input.cross_dataset {
object.key("CrossDataset").string(var_680.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_column_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ColumnConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_681) = &input.column {
#[allow(unused_mut)]
let mut object_682 = object.key("Column").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_682,
var_681,
)?;
object_682.finish();
}
if let Some(var_683) = &input.format_configuration {
#[allow(unused_mut)]
let mut object_684 = object.key("FormatConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_format_configuration(
&mut object_684,
var_683,
)?;
object_684.finish();
}
if let Some(var_685) = &input.role {
object.key("Role").string(var_685.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_analysis_defaults(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AnalysisDefaults,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_686) = &input.default_new_sheet_configuration {
#[allow(unused_mut)]
let mut object_687 = object.key("DefaultNewSheetConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_default_new_sheet_configuration(
&mut object_687,
var_686,
)?;
object_687.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_string_parameter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StringParameter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_688) = &input.name {
object.key("Name").string(var_688.as_str());
}
if let Some(var_689) = &input.values {
let mut array_690 = object.key("Values").start_array();
for item_691 in var_689 {
{
array_690.value().string(item_691.as_str());
}
}
array_690.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_integer_parameter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IntegerParameter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_692) = &input.name {
object.key("Name").string(var_692.as_str());
}
if let Some(var_693) = &input.values {
let mut array_694 = object.key("Values").start_array();
for item_695 in var_693 {
{
array_694.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*item_695).into()),
);
}
}
array_694.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_decimal_parameter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DecimalParameter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_696) = &input.name {
object.key("Name").string(var_696.as_str());
}
if let Some(var_697) = &input.values {
let mut array_698 = object.key("Values").start_array();
for item_699 in var_697 {
{
array_698.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*item_699).into()),
);
}
}
array_698.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_date_time_parameter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DateTimeParameter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_700) = &input.name {
object.key("Name").string(var_700.as_str());
}
if let Some(var_701) = &input.values {
let mut array_702 = object.key("Values").start_array();
for item_703 in var_701 {
{
array_702
.value()
.date_time(item_703, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
}
array_702.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_analysis_source_template(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AnalysisSourceTemplate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_704) = &input.data_set_references {
let mut array_705 = object.key("DataSetReferences").start_array();
for item_706 in var_704 {
{
#[allow(unused_mut)]
let mut object_707 = array_705.value().start_object();
crate::json_ser::serialize_structure_crate_model_data_set_reference(
&mut object_707,
item_706,
)?;
object_707.finish();
}
}
array_705.finish();
}
if let Some(var_708) = &input.arn {
object.key("Arn").string(var_708.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ad_hoc_filtering_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AdHocFilteringOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_709) = &input.availability_status {
object.key("AvailabilityStatus").string(var_709.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_export_to_csv_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExportToCsvOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_710) = &input.availability_status {
object.key("AvailabilityStatus").string(var_710.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sheet_controls_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SheetControlsOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_711) = &input.visibility_state {
object.key("VisibilityState").string(var_711.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_dashboard_visual_publish_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DashboardVisualPublishOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_712) = &input.export_hidden_fields_option {
#[allow(unused_mut)]
let mut object_713 = object.key("ExportHiddenFieldsOption").start_object();
crate::json_ser::serialize_structure_crate_model_export_hidden_fields_option(
&mut object_713,
var_712,
)?;
object_713.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_dashboard_source_template(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DashboardSourceTemplate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_714) = &input.data_set_references {
let mut array_715 = object.key("DataSetReferences").start_array();
for item_716 in var_714 {
{
#[allow(unused_mut)]
let mut object_717 = array_715.value().start_object();
crate::json_ser::serialize_structure_crate_model_data_set_reference(
&mut object_717,
item_716,
)?;
object_717.finish();
}
}
array_715.finish();
}
if let Some(var_718) = &input.arn {
object.key("Arn").string(var_718.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_geo_spatial_column_group(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GeoSpatialColumnGroup,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_719) = &input.name {
object.key("Name").string(var_719.as_str());
}
if let Some(var_720) = &input.country_code {
object.key("CountryCode").string(var_720.as_str());
}
if let Some(var_721) = &input.columns {
let mut array_722 = object.key("Columns").start_array();
for item_723 in var_721 {
{
array_722.value().string(item_723.as_str());
}
}
array_722.finish();
}
Ok(())
}
pub fn serialize_union_crate_model_transform_operation(
object_514: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TransformOperation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::TransformOperation::ProjectOperation(inner) => {
#[allow(unused_mut)]
let mut object_724 = object_514.key("ProjectOperation").start_object();
crate::json_ser::serialize_structure_crate_model_project_operation(
&mut object_724,
inner,
)?;
object_724.finish();
}
crate::model::TransformOperation::FilterOperation(inner) => {
#[allow(unused_mut)]
let mut object_725 = object_514.key("FilterOperation").start_object();
crate::json_ser::serialize_structure_crate_model_filter_operation(
&mut object_725,
inner,
)?;
object_725.finish();
}
crate::model::TransformOperation::CreateColumnsOperation(inner) => {
#[allow(unused_mut)]
let mut object_726 = object_514.key("CreateColumnsOperation").start_object();
crate::json_ser::serialize_structure_crate_model_create_columns_operation(
&mut object_726,
inner,
)?;
object_726.finish();
}
crate::model::TransformOperation::RenameColumnOperation(inner) => {
#[allow(unused_mut)]
let mut object_727 = object_514.key("RenameColumnOperation").start_object();
crate::json_ser::serialize_structure_crate_model_rename_column_operation(
&mut object_727,
inner,
)?;
object_727.finish();
}
crate::model::TransformOperation::CastColumnTypeOperation(inner) => {
#[allow(unused_mut)]
let mut object_728 = object_514.key("CastColumnTypeOperation").start_object();
crate::json_ser::serialize_structure_crate_model_cast_column_type_operation(
&mut object_728,
inner,
)?;
object_728.finish();
}
crate::model::TransformOperation::TagColumnOperation(inner) => {
#[allow(unused_mut)]
let mut object_729 = object_514.key("TagColumnOperation").start_object();
crate::json_ser::serialize_structure_crate_model_tag_column_operation(
&mut object_729,
inner,
)?;
object_729.finish();
}
crate::model::TransformOperation::UntagColumnOperation(inner) => {
#[allow(unused_mut)]
let mut object_730 = object_514.key("UntagColumnOperation").start_object();
crate::json_ser::serialize_structure_crate_model_untag_column_operation(
&mut object_730,
inner,
)?;
object_730.finish();
}
crate::model::TransformOperation::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"TransformOperation",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_logical_table_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LogicalTableSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_731) = &input.join_instruction {
#[allow(unused_mut)]
let mut object_732 = object.key("JoinInstruction").start_object();
crate::json_ser::serialize_structure_crate_model_join_instruction(
&mut object_732,
var_731,
)?;
object_732.finish();
}
if let Some(var_733) = &input.physical_table_id {
object.key("PhysicalTableId").string(var_733.as_str());
}
if let Some(var_734) = &input.data_set_arn {
object.key("DataSetArn").string(var_734.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_relational_table(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RelationalTable,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_735) = &input.data_source_arn {
object.key("DataSourceArn").string(var_735.as_str());
}
if let Some(var_736) = &input.catalog {
object.key("Catalog").string(var_736.as_str());
}
if let Some(var_737) = &input.schema {
object.key("Schema").string(var_737.as_str());
}
if let Some(var_738) = &input.name {
object.key("Name").string(var_738.as_str());
}
if let Some(var_739) = &input.input_columns {
let mut array_740 = object.key("InputColumns").start_array();
for item_741 in var_739 {
{
#[allow(unused_mut)]
let mut object_742 = array_740.value().start_object();
crate::json_ser::serialize_structure_crate_model_input_column(
&mut object_742,
item_741,
)?;
object_742.finish();
}
}
array_740.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_sql(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomSql,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_743) = &input.data_source_arn {
object.key("DataSourceArn").string(var_743.as_str());
}
if let Some(var_744) = &input.name {
object.key("Name").string(var_744.as_str());
}
if let Some(var_745) = &input.sql_query {
object.key("SqlQuery").string(var_745.as_str());
}
if let Some(var_746) = &input.columns {
let mut array_747 = object.key("Columns").start_array();
for item_748 in var_746 {
{
#[allow(unused_mut)]
let mut object_749 = array_747.value().start_object();
crate::json_ser::serialize_structure_crate_model_input_column(
&mut object_749,
item_748,
)?;
object_749.finish();
}
}
array_747.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3Source,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_750) = &input.data_source_arn {
object.key("DataSourceArn").string(var_750.as_str());
}
if let Some(var_751) = &input.upload_settings {
#[allow(unused_mut)]
let mut object_752 = object.key("UploadSettings").start_object();
crate::json_ser::serialize_structure_crate_model_upload_settings(&mut object_752, var_751)?;
object_752.finish();
}
if let Some(var_753) = &input.input_columns {
let mut array_754 = object.key("InputColumns").start_array();
for item_755 in var_753 {
{
#[allow(unused_mut)]
let mut object_756 = array_754.value().start_object();
crate::json_ser::serialize_structure_crate_model_input_column(
&mut object_756,
item_755,
)?;
object_756.finish();
}
}
array_754.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_row_level_permission_tag_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RowLevelPermissionTagRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_757) = &input.tag_key {
object.key("TagKey").string(var_757.as_str());
}
if let Some(var_758) = &input.column_name {
object.key("ColumnName").string(var_758.as_str());
}
if let Some(var_759) = &input.tag_multi_value_delimiter {
object
.key("TagMultiValueDelimiter")
.string(var_759.as_str());
}
if let Some(var_760) = &input.match_all_value {
object.key("MatchAllValue").string(var_760.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_credential_pair(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CredentialPair,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_761) = &input.username {
object.key("Username").string(var_761.as_str());
}
if let Some(var_762) = &input.password {
object.key("Password").string(var_762.as_str());
}
if let Some(var_763) = &input.alternate_data_source_parameters {
let mut array_764 = object.key("AlternateDataSourceParameters").start_array();
for item_765 in var_763 {
{
#[allow(unused_mut)]
let mut object_766 = array_764.value().start_object();
crate::json_ser::serialize_union_crate_model_data_source_parameters(
&mut object_766,
item_765,
)?;
object_766.finish();
}
}
array_764.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_amazon_elasticsearch_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AmazonElasticsearchParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_767) = &input.domain {
object.key("Domain").string(var_767.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_athena_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AthenaParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_768) = &input.work_group {
object.key("WorkGroup").string(var_768.as_str());
}
if let Some(var_769) = &input.role_arn {
object.key("RoleArn").string(var_769.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aurora_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AuroraParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_770) = &input.host {
object.key("Host").string(var_770.as_str());
}
{
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port).into()),
);
}
if let Some(var_771) = &input.database {
object.key("Database").string(var_771.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aurora_postgre_sql_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AuroraPostgreSqlParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_772) = &input.host {
object.key("Host").string(var_772.as_str());
}
{
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port).into()),
);
}
if let Some(var_773) = &input.database {
object.key("Database").string(var_773.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_iot_analytics_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsIotAnalyticsParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_774) = &input.data_set_name {
object.key("DataSetName").string(var_774.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_jira_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JiraParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_775) = &input.site_base_url {
object.key("SiteBaseUrl").string(var_775.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_maria_db_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MariaDbParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_776) = &input.host {
object.key("Host").string(var_776.as_str());
}
{
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port).into()),
);
}
if let Some(var_777) = &input.database {
object.key("Database").string(var_777.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_my_sql_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MySqlParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_778) = &input.host {
object.key("Host").string(var_778.as_str());
}
{
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port).into()),
);
}
if let Some(var_779) = &input.database {
object.key("Database").string(var_779.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_oracle_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OracleParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_780) = &input.host {
object.key("Host").string(var_780.as_str());
}
{
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port).into()),
);
}
if let Some(var_781) = &input.database {
object.key("Database").string(var_781.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_postgre_sql_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PostgreSqlParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_782) = &input.host {
object.key("Host").string(var_782.as_str());
}
{
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port).into()),
);
}
if let Some(var_783) = &input.database {
object.key("Database").string(var_783.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_presto_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PrestoParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_784) = &input.host {
object.key("Host").string(var_784.as_str());
}
{
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port).into()),
);
}
if let Some(var_785) = &input.catalog {
object.key("Catalog").string(var_785.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_rds_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RdsParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_786) = &input.instance_id {
object.key("InstanceId").string(var_786.as_str());
}
if let Some(var_787) = &input.database {
object.key("Database").string(var_787.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_redshift_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RedshiftParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_788) = &input.host {
object.key("Host").string(var_788.as_str());
}
if input.port != 0 {
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port).into()),
);
}
if let Some(var_789) = &input.database {
object.key("Database").string(var_789.as_str());
}
if let Some(var_790) = &input.cluster_id {
object.key("ClusterId").string(var_790.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3Parameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_791) = &input.manifest_file_location {
#[allow(unused_mut)]
let mut object_792 = object.key("ManifestFileLocation").start_object();
crate::json_ser::serialize_structure_crate_model_manifest_file_location(
&mut object_792,
var_791,
)?;
object_792.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_service_now_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServiceNowParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_793) = &input.site_base_url {
object.key("SiteBaseUrl").string(var_793.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_snowflake_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SnowflakeParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_794) = &input.host {
object.key("Host").string(var_794.as_str());
}
if let Some(var_795) = &input.database {
object.key("Database").string(var_795.as_str());
}
if let Some(var_796) = &input.warehouse {
object.key("Warehouse").string(var_796.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_spark_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SparkParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_797) = &input.host {
object.key("Host").string(var_797.as_str());
}
{
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_sql_server_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SqlServerParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_798) = &input.host {
object.key("Host").string(var_798.as_str());
}
{
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port).into()),
);
}
if let Some(var_799) = &input.database {
object.key("Database").string(var_799.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_teradata_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TeradataParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_800) = &input.host {
object.key("Host").string(var_800.as_str());
}
{
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port).into()),
);
}
if let Some(var_801) = &input.database {
object.key("Database").string(var_801.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_twitter_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TwitterParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_802) = &input.query {
object.key("Query").string(var_802.as_str());
}
{
object.key("MaxRows").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_rows).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_amazon_open_search_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AmazonOpenSearchParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_803) = &input.domain {
object.key("Domain").string(var_803.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_exasol_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExasolParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_804) = &input.host {
object.key("Host").string(var_804.as_str());
}
{
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_databricks_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatabricksParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_805) = &input.host {
object.key("Host").string(var_805.as_str());
}
{
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port).into()),
);
}
if let Some(var_806) = &input.sql_endpoint_path {
object.key("SqlEndpointPath").string(var_806.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_data_set_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataSetConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_807) = &input.placeholder {
object.key("Placeholder").string(var_807.as_str());
}
if let Some(var_808) = &input.data_set_schema {
#[allow(unused_mut)]
let mut object_809 = object.key("DataSetSchema").start_object();
crate::json_ser::serialize_structure_crate_model_data_set_schema(&mut object_809, var_808)?;
object_809.finish();
}
if let Some(var_810) = &input.column_group_schema_list {
let mut array_811 = object.key("ColumnGroupSchemaList").start_array();
for item_812 in var_810 {
{
#[allow(unused_mut)]
let mut object_813 = array_811.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_group_schema(
&mut object_813,
item_812,
)?;
object_813.finish();
}
}
array_811.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_template_source_analysis(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TemplateSourceAnalysis,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_814) = &input.arn {
object.key("Arn").string(var_814.as_str());
}
if let Some(var_815) = &input.data_set_references {
let mut array_816 = object.key("DataSetReferences").start_array();
for item_817 in var_815 {
{
#[allow(unused_mut)]
let mut object_818 = array_816.value().start_object();
crate::json_ser::serialize_structure_crate_model_data_set_reference(
&mut object_818,
item_817,
)?;
object_818.finish();
}
}
array_816.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_template_source_template(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TemplateSourceTemplate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_819) = &input.arn {
object.key("Arn").string(var_819.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_data_color_palette(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataColorPalette,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_820) = &input.colors {
let mut array_821 = object.key("Colors").start_array();
for item_822 in var_820 {
{
array_821.value().string(item_822.as_str());
}
}
array_821.finish();
}
if let Some(var_823) = &input.min_max_gradient {
let mut array_824 = object.key("MinMaxGradient").start_array();
for item_825 in var_823 {
{
array_824.value().string(item_825.as_str());
}
}
array_824.finish();
}
if let Some(var_826) = &input.empty_fill_color {
object.key("EmptyFillColor").string(var_826.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ui_color_palette(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UiColorPalette,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_827) = &input.primary_foreground {
object.key("PrimaryForeground").string(var_827.as_str());
}
if let Some(var_828) = &input.primary_background {
object.key("PrimaryBackground").string(var_828.as_str());
}
if let Some(var_829) = &input.secondary_foreground {
object.key("SecondaryForeground").string(var_829.as_str());
}
if let Some(var_830) = &input.secondary_background {
object.key("SecondaryBackground").string(var_830.as_str());
}
if let Some(var_831) = &input.accent {
object.key("Accent").string(var_831.as_str());
}
if let Some(var_832) = &input.accent_foreground {
object.key("AccentForeground").string(var_832.as_str());
}
if let Some(var_833) = &input.danger {
object.key("Danger").string(var_833.as_str());
}
if let Some(var_834) = &input.danger_foreground {
object.key("DangerForeground").string(var_834.as_str());
}
if let Some(var_835) = &input.warning {
object.key("Warning").string(var_835.as_str());
}
if let Some(var_836) = &input.warning_foreground {
object.key("WarningForeground").string(var_836.as_str());
}
if let Some(var_837) = &input.success {
object.key("Success").string(var_837.as_str());
}
if let Some(var_838) = &input.success_foreground {
object.key("SuccessForeground").string(var_838.as_str());
}
if let Some(var_839) = &input.dimension {
object.key("Dimension").string(var_839.as_str());
}
if let Some(var_840) = &input.dimension_foreground {
object.key("DimensionForeground").string(var_840.as_str());
}
if let Some(var_841) = &input.measure {
object.key("Measure").string(var_841.as_str());
}
if let Some(var_842) = &input.measure_foreground {
object.key("MeasureForeground").string(var_842.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sheet_style(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SheetStyle,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_843) = &input.tile {
#[allow(unused_mut)]
let mut object_844 = object.key("Tile").start_object();
crate::json_ser::serialize_structure_crate_model_tile_style(&mut object_844, var_843)?;
object_844.finish();
}
if let Some(var_845) = &input.tile_layout {
#[allow(unused_mut)]
let mut object_846 = object.key("TileLayout").start_object();
crate::json_ser::serialize_structure_crate_model_tile_layout_style(
&mut object_846,
var_845,
)?;
object_846.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_typography(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Typography,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_847) = &input.font_families {
let mut array_848 = object.key("FontFamilies").start_array();
for item_849 in var_847 {
{
#[allow(unused_mut)]
let mut object_850 = array_848.value().start_object();
crate::json_ser::serialize_structure_crate_model_font(&mut object_850, item_849)?;
object_850.finish();
}
}
array_848.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_anonymous_user_dashboard_embedding_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AnonymousUserDashboardEmbeddingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_851) = &input.initial_dashboard_id {
object.key("InitialDashboardId").string(var_851.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_anonymous_user_dashboard_visual_embedding_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AnonymousUserDashboardVisualEmbeddingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_852) = &input.initial_dashboard_visual_id {
#[allow(unused_mut)]
let mut object_853 = object.key("InitialDashboardVisualId").start_object();
crate::json_ser::serialize_structure_crate_model_dashboard_visual_id(
&mut object_853,
var_852,
)?;
object_853.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_anonymous_user_q_search_bar_embedding_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AnonymousUserQSearchBarEmbeddingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_854) = &input.initial_topic_id {
object.key("InitialTopicId").string(var_854.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_registered_user_dashboard_embedding_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RegisteredUserDashboardEmbeddingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_855) = &input.initial_dashboard_id {
object.key("InitialDashboardId").string(var_855.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_registered_user_quick_sight_console_embedding_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RegisteredUserQuickSightConsoleEmbeddingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_856) = &input.initial_path {
object.key("InitialPath").string(var_856.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_registered_user_q_search_bar_embedding_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RegisteredUserQSearchBarEmbeddingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_857) = &input.initial_topic_id {
object.key("InitialTopicId").string(var_857.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_registered_user_dashboard_visual_embedding_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RegisteredUserDashboardVisualEmbeddingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_858) = &input.initial_dashboard_visual_id {
#[allow(unused_mut)]
let mut object_859 = object.key("InitialDashboardVisualId").start_object();
crate::json_ser::serialize_structure_crate_model_dashboard_visual_id(
&mut object_859,
var_858,
)?;
object_859.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_parameter_control(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParameterControl,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_860) = &input.date_time_picker {
#[allow(unused_mut)]
let mut object_861 = object.key("DateTimePicker").start_object();
crate::json_ser::serialize_structure_crate_model_parameter_date_time_picker_control(
&mut object_861,
var_860,
)?;
object_861.finish();
}
if let Some(var_862) = &input.list {
#[allow(unused_mut)]
let mut object_863 = object.key("List").start_object();
crate::json_ser::serialize_structure_crate_model_parameter_list_control(
&mut object_863,
var_862,
)?;
object_863.finish();
}
if let Some(var_864) = &input.dropdown {
#[allow(unused_mut)]
let mut object_865 = object.key("Dropdown").start_object();
crate::json_ser::serialize_structure_crate_model_parameter_drop_down_control(
&mut object_865,
var_864,
)?;
object_865.finish();
}
if let Some(var_866) = &input.text_field {
#[allow(unused_mut)]
let mut object_867 = object.key("TextField").start_object();
crate::json_ser::serialize_structure_crate_model_parameter_text_field_control(
&mut object_867,
var_866,
)?;
object_867.finish();
}
if let Some(var_868) = &input.text_area {
#[allow(unused_mut)]
let mut object_869 = object.key("TextArea").start_object();
crate::json_ser::serialize_structure_crate_model_parameter_text_area_control(
&mut object_869,
var_868,
)?;
object_869.finish();
}
if let Some(var_870) = &input.slider {
#[allow(unused_mut)]
let mut object_871 = object.key("Slider").start_object();
crate::json_ser::serialize_structure_crate_model_parameter_slider_control(
&mut object_871,
var_870,
)?;
object_871.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_control(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterControl,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_872) = &input.date_time_picker {
#[allow(unused_mut)]
let mut object_873 = object.key("DateTimePicker").start_object();
crate::json_ser::serialize_structure_crate_model_filter_date_time_picker_control(
&mut object_873,
var_872,
)?;
object_873.finish();
}
if let Some(var_874) = &input.list {
#[allow(unused_mut)]
let mut object_875 = object.key("List").start_object();
crate::json_ser::serialize_structure_crate_model_filter_list_control(
&mut object_875,
var_874,
)?;
object_875.finish();
}
if let Some(var_876) = &input.dropdown {
#[allow(unused_mut)]
let mut object_877 = object.key("Dropdown").start_object();
crate::json_ser::serialize_structure_crate_model_filter_drop_down_control(
&mut object_877,
var_876,
)?;
object_877.finish();
}
if let Some(var_878) = &input.text_field {
#[allow(unused_mut)]
let mut object_879 = object.key("TextField").start_object();
crate::json_ser::serialize_structure_crate_model_filter_text_field_control(
&mut object_879,
var_878,
)?;
object_879.finish();
}
if let Some(var_880) = &input.text_area {
#[allow(unused_mut)]
let mut object_881 = object.key("TextArea").start_object();
crate::json_ser::serialize_structure_crate_model_filter_text_area_control(
&mut object_881,
var_880,
)?;
object_881.finish();
}
if let Some(var_882) = &input.slider {
#[allow(unused_mut)]
let mut object_883 = object.key("Slider").start_object();
crate::json_ser::serialize_structure_crate_model_filter_slider_control(
&mut object_883,
var_882,
)?;
object_883.finish();
}
if let Some(var_884) = &input.relative_date_time {
#[allow(unused_mut)]
let mut object_885 = object.key("RelativeDateTime").start_object();
crate::json_ser::serialize_structure_crate_model_filter_relative_date_time_control(
&mut object_885,
var_884,
)?;
object_885.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_visual(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Visual,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_886) = &input.table_visual {
#[allow(unused_mut)]
let mut object_887 = object.key("TableVisual").start_object();
crate::json_ser::serialize_structure_crate_model_table_visual(&mut object_887, var_886)?;
object_887.finish();
}
if let Some(var_888) = &input.pivot_table_visual {
#[allow(unused_mut)]
let mut object_889 = object.key("PivotTableVisual").start_object();
crate::json_ser::serialize_structure_crate_model_pivot_table_visual(
&mut object_889,
var_888,
)?;
object_889.finish();
}
if let Some(var_890) = &input.bar_chart_visual {
#[allow(unused_mut)]
let mut object_891 = object.key("BarChartVisual").start_object();
crate::json_ser::serialize_structure_crate_model_bar_chart_visual(
&mut object_891,
var_890,
)?;
object_891.finish();
}
if let Some(var_892) = &input.kpi_visual {
#[allow(unused_mut)]
let mut object_893 = object.key("KPIVisual").start_object();
crate::json_ser::serialize_structure_crate_model_kpi_visual(&mut object_893, var_892)?;
object_893.finish();
}
if let Some(var_894) = &input.pie_chart_visual {
#[allow(unused_mut)]
let mut object_895 = object.key("PieChartVisual").start_object();
crate::json_ser::serialize_structure_crate_model_pie_chart_visual(
&mut object_895,
var_894,
)?;
object_895.finish();
}
if let Some(var_896) = &input.gauge_chart_visual {
#[allow(unused_mut)]
let mut object_897 = object.key("GaugeChartVisual").start_object();
crate::json_ser::serialize_structure_crate_model_gauge_chart_visual(
&mut object_897,
var_896,
)?;
object_897.finish();
}
if let Some(var_898) = &input.line_chart_visual {
#[allow(unused_mut)]
let mut object_899 = object.key("LineChartVisual").start_object();
crate::json_ser::serialize_structure_crate_model_line_chart_visual(
&mut object_899,
var_898,
)?;
object_899.finish();
}
if let Some(var_900) = &input.heat_map_visual {
#[allow(unused_mut)]
let mut object_901 = object.key("HeatMapVisual").start_object();
crate::json_ser::serialize_structure_crate_model_heat_map_visual(&mut object_901, var_900)?;
object_901.finish();
}
if let Some(var_902) = &input.tree_map_visual {
#[allow(unused_mut)]
let mut object_903 = object.key("TreeMapVisual").start_object();
crate::json_ser::serialize_structure_crate_model_tree_map_visual(&mut object_903, var_902)?;
object_903.finish();
}
if let Some(var_904) = &input.geospatial_map_visual {
#[allow(unused_mut)]
let mut object_905 = object.key("GeospatialMapVisual").start_object();
crate::json_ser::serialize_structure_crate_model_geospatial_map_visual(
&mut object_905,
var_904,
)?;
object_905.finish();
}
if let Some(var_906) = &input.filled_map_visual {
#[allow(unused_mut)]
let mut object_907 = object.key("FilledMapVisual").start_object();
crate::json_ser::serialize_structure_crate_model_filled_map_visual(
&mut object_907,
var_906,
)?;
object_907.finish();
}
if let Some(var_908) = &input.funnel_chart_visual {
#[allow(unused_mut)]
let mut object_909 = object.key("FunnelChartVisual").start_object();
crate::json_ser::serialize_structure_crate_model_funnel_chart_visual(
&mut object_909,
var_908,
)?;
object_909.finish();
}
if let Some(var_910) = &input.scatter_plot_visual {
#[allow(unused_mut)]
let mut object_911 = object.key("ScatterPlotVisual").start_object();
crate::json_ser::serialize_structure_crate_model_scatter_plot_visual(
&mut object_911,
var_910,
)?;
object_911.finish();
}
if let Some(var_912) = &input.combo_chart_visual {
#[allow(unused_mut)]
let mut object_913 = object.key("ComboChartVisual").start_object();
crate::json_ser::serialize_structure_crate_model_combo_chart_visual(
&mut object_913,
var_912,
)?;
object_913.finish();
}
if let Some(var_914) = &input.box_plot_visual {
#[allow(unused_mut)]
let mut object_915 = object.key("BoxPlotVisual").start_object();
crate::json_ser::serialize_structure_crate_model_box_plot_visual(&mut object_915, var_914)?;
object_915.finish();
}
if let Some(var_916) = &input.waterfall_visual {
#[allow(unused_mut)]
let mut object_917 = object.key("WaterfallVisual").start_object();
crate::json_ser::serialize_structure_crate_model_waterfall_visual(
&mut object_917,
var_916,
)?;
object_917.finish();
}
if let Some(var_918) = &input.histogram_visual {
#[allow(unused_mut)]
let mut object_919 = object.key("HistogramVisual").start_object();
crate::json_ser::serialize_structure_crate_model_histogram_visual(
&mut object_919,
var_918,
)?;
object_919.finish();
}
if let Some(var_920) = &input.word_cloud_visual {
#[allow(unused_mut)]
let mut object_921 = object.key("WordCloudVisual").start_object();
crate::json_ser::serialize_structure_crate_model_word_cloud_visual(
&mut object_921,
var_920,
)?;
object_921.finish();
}
if let Some(var_922) = &input.insight_visual {
#[allow(unused_mut)]
let mut object_923 = object.key("InsightVisual").start_object();
crate::json_ser::serialize_structure_crate_model_insight_visual(&mut object_923, var_922)?;
object_923.finish();
}
if let Some(var_924) = &input.sankey_diagram_visual {
#[allow(unused_mut)]
let mut object_925 = object.key("SankeyDiagramVisual").start_object();
crate::json_ser::serialize_structure_crate_model_sankey_diagram_visual(
&mut object_925,
var_924,
)?;
object_925.finish();
}
if let Some(var_926) = &input.custom_content_visual {
#[allow(unused_mut)]
let mut object_927 = object.key("CustomContentVisual").start_object();
crate::json_ser::serialize_structure_crate_model_custom_content_visual(
&mut object_927,
var_926,
)?;
object_927.finish();
}
if let Some(var_928) = &input.empty_visual {
#[allow(unused_mut)]
let mut object_929 = object.key("EmptyVisual").start_object();
crate::json_ser::serialize_structure_crate_model_empty_visual(&mut object_929, var_928)?;
object_929.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sheet_text_box(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SheetTextBox,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_930) = &input.sheet_text_box_id {
object.key("SheetTextBoxId").string(var_930.as_str());
}
if let Some(var_931) = &input.content {
object.key("Content").string(var_931.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_layout(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Layout,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_932) = &input.configuration {
#[allow(unused_mut)]
let mut object_933 = object.key("Configuration").start_object();
crate::json_ser::serialize_structure_crate_model_layout_configuration(
&mut object_933,
var_932,
)?;
object_933.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sheet_control_layout(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SheetControlLayout,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_934) = &input.configuration {
#[allow(unused_mut)]
let mut object_935 = object.key("Configuration").start_object();
crate::json_ser::serialize_structure_crate_model_sheet_control_layout_configuration(
&mut object_935,
var_934,
)?;
object_935.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_string_parameter_declaration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StringParameterDeclaration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_936) = &input.parameter_value_type {
object.key("ParameterValueType").string(var_936.as_str());
}
if let Some(var_937) = &input.name {
object.key("Name").string(var_937.as_str());
}
if let Some(var_938) = &input.default_values {
#[allow(unused_mut)]
let mut object_939 = object.key("DefaultValues").start_object();
crate::json_ser::serialize_structure_crate_model_string_default_values(
&mut object_939,
var_938,
)?;
object_939.finish();
}
if let Some(var_940) = &input.value_when_unset {
#[allow(unused_mut)]
let mut object_941 = object.key("ValueWhenUnset").start_object();
crate::json_ser::serialize_structure_crate_model_string_value_when_unset_configuration(
&mut object_941,
var_940,
)?;
object_941.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_decimal_parameter_declaration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DecimalParameterDeclaration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_942) = &input.parameter_value_type {
object.key("ParameterValueType").string(var_942.as_str());
}
if let Some(var_943) = &input.name {
object.key("Name").string(var_943.as_str());
}
if let Some(var_944) = &input.default_values {
#[allow(unused_mut)]
let mut object_945 = object.key("DefaultValues").start_object();
crate::json_ser::serialize_structure_crate_model_decimal_default_values(
&mut object_945,
var_944,
)?;
object_945.finish();
}
if let Some(var_946) = &input.value_when_unset {
#[allow(unused_mut)]
let mut object_947 = object.key("ValueWhenUnset").start_object();
crate::json_ser::serialize_structure_crate_model_decimal_value_when_unset_configuration(
&mut object_947,
var_946,
)?;
object_947.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_integer_parameter_declaration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IntegerParameterDeclaration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_948) = &input.parameter_value_type {
object.key("ParameterValueType").string(var_948.as_str());
}
if let Some(var_949) = &input.name {
object.key("Name").string(var_949.as_str());
}
if let Some(var_950) = &input.default_values {
#[allow(unused_mut)]
let mut object_951 = object.key("DefaultValues").start_object();
crate::json_ser::serialize_structure_crate_model_integer_default_values(
&mut object_951,
var_950,
)?;
object_951.finish();
}
if let Some(var_952) = &input.value_when_unset {
#[allow(unused_mut)]
let mut object_953 = object.key("ValueWhenUnset").start_object();
crate::json_ser::serialize_structure_crate_model_integer_value_when_unset_configuration(
&mut object_953,
var_952,
)?;
object_953.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_date_time_parameter_declaration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DateTimeParameterDeclaration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_954) = &input.name {
object.key("Name").string(var_954.as_str());
}
if let Some(var_955) = &input.default_values {
#[allow(unused_mut)]
let mut object_956 = object.key("DefaultValues").start_object();
crate::json_ser::serialize_structure_crate_model_date_time_default_values(
&mut object_956,
var_955,
)?;
object_956.finish();
}
if let Some(var_957) = &input.time_granularity {
object.key("TimeGranularity").string(var_957.as_str());
}
if let Some(var_958) = &input.value_when_unset {
#[allow(unused_mut)]
let mut object_959 = object.key("ValueWhenUnset").start_object();
crate::json_ser::serialize_structure_crate_model_date_time_value_when_unset_configuration(
&mut object_959,
var_958,
)?;
object_959.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Filter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_960) = &input.category_filter {
#[allow(unused_mut)]
let mut object_961 = object.key("CategoryFilter").start_object();
crate::json_ser::serialize_structure_crate_model_category_filter(&mut object_961, var_960)?;
object_961.finish();
}
if let Some(var_962) = &input.numeric_range_filter {
#[allow(unused_mut)]
let mut object_963 = object.key("NumericRangeFilter").start_object();
crate::json_ser::serialize_structure_crate_model_numeric_range_filter(
&mut object_963,
var_962,
)?;
object_963.finish();
}
if let Some(var_964) = &input.numeric_equality_filter {
#[allow(unused_mut)]
let mut object_965 = object.key("NumericEqualityFilter").start_object();
crate::json_ser::serialize_structure_crate_model_numeric_equality_filter(
&mut object_965,
var_964,
)?;
object_965.finish();
}
if let Some(var_966) = &input.time_equality_filter {
#[allow(unused_mut)]
let mut object_967 = object.key("TimeEqualityFilter").start_object();
crate::json_ser::serialize_structure_crate_model_time_equality_filter(
&mut object_967,
var_966,
)?;
object_967.finish();
}
if let Some(var_968) = &input.time_range_filter {
#[allow(unused_mut)]
let mut object_969 = object.key("TimeRangeFilter").start_object();
crate::json_ser::serialize_structure_crate_model_time_range_filter(
&mut object_969,
var_968,
)?;
object_969.finish();
}
if let Some(var_970) = &input.relative_dates_filter {
#[allow(unused_mut)]
let mut object_971 = object.key("RelativeDatesFilter").start_object();
crate::json_ser::serialize_structure_crate_model_relative_dates_filter(
&mut object_971,
var_970,
)?;
object_971.finish();
}
if let Some(var_972) = &input.top_bottom_filter {
#[allow(unused_mut)]
let mut object_973 = object.key("TopBottomFilter").start_object();
crate::json_ser::serialize_structure_crate_model_top_bottom_filter(
&mut object_973,
var_972,
)?;
object_973.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_scope_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterScopeConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_974) = &input.selected_sheets {
#[allow(unused_mut)]
let mut object_975 = object.key("SelectedSheets").start_object();
crate::json_ser::serialize_structure_crate_model_selected_sheets_filter_scope_configuration(&mut object_975, var_974)?;
object_975.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_column_identifier(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ColumnIdentifier,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_976) = &input.data_set_identifier {
object.key("DataSetIdentifier").string(var_976.as_str());
}
if let Some(var_977) = &input.column_name {
object.key("ColumnName").string(var_977.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_format_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FormatConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_978) = &input.string_format_configuration {
#[allow(unused_mut)]
let mut object_979 = object.key("StringFormatConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_string_format_configuration(
&mut object_979,
var_978,
)?;
object_979.finish();
}
if let Some(var_980) = &input.number_format_configuration {
#[allow(unused_mut)]
let mut object_981 = object.key("NumberFormatConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_number_format_configuration(
&mut object_981,
var_980,
)?;
object_981.finish();
}
if let Some(var_982) = &input.date_time_format_configuration {
#[allow(unused_mut)]
let mut object_983 = object.key("DateTimeFormatConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_date_time_format_configuration(
&mut object_983,
var_982,
)?;
object_983.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_default_new_sheet_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DefaultNewSheetConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_984) = &input.interactive_layout_configuration {
#[allow(unused_mut)]
let mut object_985 = object.key("InteractiveLayoutConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_default_interactive_layout_configuration(
&mut object_985,
var_984,
)?;
object_985.finish();
}
if let Some(var_986) = &input.paginated_layout_configuration {
#[allow(unused_mut)]
let mut object_987 = object.key("PaginatedLayoutConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_default_paginated_layout_configuration(
&mut object_987,
var_986,
)?;
object_987.finish();
}
if let Some(var_988) = &input.sheet_content_type {
object.key("SheetContentType").string(var_988.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_data_set_reference(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataSetReference,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_989) = &input.data_set_placeholder {
object.key("DataSetPlaceholder").string(var_989.as_str());
}
if let Some(var_990) = &input.data_set_arn {
object.key("DataSetArn").string(var_990.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_export_hidden_fields_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExportHiddenFieldsOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_991) = &input.availability_status {
object.key("AvailabilityStatus").string(var_991.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_project_operation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProjectOperation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_992) = &input.projected_columns {
let mut array_993 = object.key("ProjectedColumns").start_array();
for item_994 in var_992 {
{
array_993.value().string(item_994.as_str());
}
}
array_993.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_operation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterOperation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_995) = &input.condition_expression {
object.key("ConditionExpression").string(var_995.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_create_columns_operation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateColumnsOperation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_996) = &input.columns {
let mut array_997 = object.key("Columns").start_array();
for item_998 in var_996 {
{
#[allow(unused_mut)]
let mut object_999 = array_997.value().start_object();
crate::json_ser::serialize_structure_crate_model_calculated_column(
&mut object_999,
item_998,
)?;
object_999.finish();
}
}
array_997.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_rename_column_operation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RenameColumnOperation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1000) = &input.column_name {
object.key("ColumnName").string(var_1000.as_str());
}
if let Some(var_1001) = &input.new_column_name {
object.key("NewColumnName").string(var_1001.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_cast_column_type_operation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CastColumnTypeOperation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1002) = &input.column_name {
object.key("ColumnName").string(var_1002.as_str());
}
if let Some(var_1003) = &input.new_column_type {
object.key("NewColumnType").string(var_1003.as_str());
}
if let Some(var_1004) = &input.format {
object.key("Format").string(var_1004.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tag_column_operation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TagColumnOperation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1005) = &input.column_name {
object.key("ColumnName").string(var_1005.as_str());
}
if let Some(var_1006) = &input.tags {
let mut array_1007 = object.key("Tags").start_array();
for item_1008 in var_1006 {
{
#[allow(unused_mut)]
let mut object_1009 = array_1007.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_tag(
&mut object_1009,
item_1008,
)?;
object_1009.finish();
}
}
array_1007.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_untag_column_operation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UntagColumnOperation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1010) = &input.column_name {
object.key("ColumnName").string(var_1010.as_str());
}
if let Some(var_1011) = &input.tag_names {
let mut array_1012 = object.key("TagNames").start_array();
for item_1013 in var_1011 {
{
array_1012.value().string(item_1013.as_str());
}
}
array_1012.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_join_instruction(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JoinInstruction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1014) = &input.left_operand {
object.key("LeftOperand").string(var_1014.as_str());
}
if let Some(var_1015) = &input.right_operand {
object.key("RightOperand").string(var_1015.as_str());
}
if let Some(var_1016) = &input.left_join_key_properties {
#[allow(unused_mut)]
let mut object_1017 = object.key("LeftJoinKeyProperties").start_object();
crate::json_ser::serialize_structure_crate_model_join_key_properties(
&mut object_1017,
var_1016,
)?;
object_1017.finish();
}
if let Some(var_1018) = &input.right_join_key_properties {
#[allow(unused_mut)]
let mut object_1019 = object.key("RightJoinKeyProperties").start_object();
crate::json_ser::serialize_structure_crate_model_join_key_properties(
&mut object_1019,
var_1018,
)?;
object_1019.finish();
}
if let Some(var_1020) = &input.r#type {
object.key("Type").string(var_1020.as_str());
}
if let Some(var_1021) = &input.on_clause {
object.key("OnClause").string(var_1021.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_input_column(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InputColumn,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1022) = &input.name {
object.key("Name").string(var_1022.as_str());
}
if let Some(var_1023) = &input.r#type {
object.key("Type").string(var_1023.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_upload_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UploadSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1024) = &input.format {
object.key("Format").string(var_1024.as_str());
}
if let Some(var_1025) = &input.start_from_row {
object.key("StartFromRow").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1025).into()),
);
}
if let Some(var_1026) = &input.contains_header {
object.key("ContainsHeader").boolean(*var_1026);
}
if let Some(var_1027) = &input.text_qualifier {
object.key("TextQualifier").string(var_1027.as_str());
}
if let Some(var_1028) = &input.delimiter {
object.key("Delimiter").string(var_1028.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_manifest_file_location(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ManifestFileLocation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1029) = &input.bucket {
object.key("Bucket").string(var_1029.as_str());
}
if let Some(var_1030) = &input.key {
object.key("Key").string(var_1030.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_data_set_schema(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataSetSchema,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1031) = &input.column_schema_list {
let mut array_1032 = object.key("ColumnSchemaList").start_array();
for item_1033 in var_1031 {
{
#[allow(unused_mut)]
let mut object_1034 = array_1032.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_schema(
&mut object_1034,
item_1033,
)?;
object_1034.finish();
}
}
array_1032.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_column_group_schema(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ColumnGroupSchema,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1035) = &input.name {
object.key("Name").string(var_1035.as_str());
}
if let Some(var_1036) = &input.column_group_column_schema_list {
let mut array_1037 = object.key("ColumnGroupColumnSchemaList").start_array();
for item_1038 in var_1036 {
{
#[allow(unused_mut)]
let mut object_1039 = array_1037.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_group_column_schema(
&mut object_1039,
item_1038,
)?;
object_1039.finish();
}
}
array_1037.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tile_style(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TileStyle,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1040) = &input.border {
#[allow(unused_mut)]
let mut object_1041 = object.key("Border").start_object();
crate::json_ser::serialize_structure_crate_model_border_style(&mut object_1041, var_1040)?;
object_1041.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tile_layout_style(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TileLayoutStyle,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1042) = &input.gutter {
#[allow(unused_mut)]
let mut object_1043 = object.key("Gutter").start_object();
crate::json_ser::serialize_structure_crate_model_gutter_style(&mut object_1043, var_1042)?;
object_1043.finish();
}
if let Some(var_1044) = &input.margin {
#[allow(unused_mut)]
let mut object_1045 = object.key("Margin").start_object();
crate::json_ser::serialize_structure_crate_model_margin_style(&mut object_1045, var_1044)?;
object_1045.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_font(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Font,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1046) = &input.font_family {
object.key("FontFamily").string(var_1046.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_dashboard_visual_id(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DashboardVisualId,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1047) = &input.dashboard_id {
object.key("DashboardId").string(var_1047.as_str());
}
if let Some(var_1048) = &input.sheet_id {
object.key("SheetId").string(var_1048.as_str());
}
if let Some(var_1049) = &input.visual_id {
object.key("VisualId").string(var_1049.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_parameter_date_time_picker_control(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParameterDateTimePickerControl,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1050) = &input.parameter_control_id {
object.key("ParameterControlId").string(var_1050.as_str());
}
if let Some(var_1051) = &input.title {
object.key("Title").string(var_1051.as_str());
}
if let Some(var_1052) = &input.source_parameter_name {
object.key("SourceParameterName").string(var_1052.as_str());
}
if let Some(var_1053) = &input.display_options {
#[allow(unused_mut)]
let mut object_1054 = object.key("DisplayOptions").start_object();
crate::json_ser::serialize_structure_crate_model_date_time_picker_control_display_options(
&mut object_1054,
var_1053,
)?;
object_1054.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_parameter_list_control(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParameterListControl,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1055) = &input.parameter_control_id {
object.key("ParameterControlId").string(var_1055.as_str());
}
if let Some(var_1056) = &input.title {
object.key("Title").string(var_1056.as_str());
}
if let Some(var_1057) = &input.source_parameter_name {
object.key("SourceParameterName").string(var_1057.as_str());
}
if let Some(var_1058) = &input.display_options {
#[allow(unused_mut)]
let mut object_1059 = object.key("DisplayOptions").start_object();
crate::json_ser::serialize_structure_crate_model_list_control_display_options(
&mut object_1059,
var_1058,
)?;
object_1059.finish();
}
if let Some(var_1060) = &input.r#type {
object.key("Type").string(var_1060.as_str());
}
if let Some(var_1061) = &input.selectable_values {
#[allow(unused_mut)]
let mut object_1062 = object.key("SelectableValues").start_object();
crate::json_ser::serialize_structure_crate_model_parameter_selectable_values(
&mut object_1062,
var_1061,
)?;
object_1062.finish();
}
if let Some(var_1063) = &input.cascading_control_configuration {
#[allow(unused_mut)]
let mut object_1064 = object.key("CascadingControlConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_cascading_control_configuration(
&mut object_1064,
var_1063,
)?;
object_1064.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_parameter_drop_down_control(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParameterDropDownControl,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1065) = &input.parameter_control_id {
object.key("ParameterControlId").string(var_1065.as_str());
}
if let Some(var_1066) = &input.title {
object.key("Title").string(var_1066.as_str());
}
if let Some(var_1067) = &input.source_parameter_name {
object.key("SourceParameterName").string(var_1067.as_str());
}
if let Some(var_1068) = &input.display_options {
#[allow(unused_mut)]
let mut object_1069 = object.key("DisplayOptions").start_object();
crate::json_ser::serialize_structure_crate_model_drop_down_control_display_options(
&mut object_1069,
var_1068,
)?;
object_1069.finish();
}
if let Some(var_1070) = &input.r#type {
object.key("Type").string(var_1070.as_str());
}
if let Some(var_1071) = &input.selectable_values {
#[allow(unused_mut)]
let mut object_1072 = object.key("SelectableValues").start_object();
crate::json_ser::serialize_structure_crate_model_parameter_selectable_values(
&mut object_1072,
var_1071,
)?;
object_1072.finish();
}
if let Some(var_1073) = &input.cascading_control_configuration {
#[allow(unused_mut)]
let mut object_1074 = object.key("CascadingControlConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_cascading_control_configuration(
&mut object_1074,
var_1073,
)?;
object_1074.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_parameter_text_field_control(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParameterTextFieldControl,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1075) = &input.parameter_control_id {
object.key("ParameterControlId").string(var_1075.as_str());
}
if let Some(var_1076) = &input.title {
object.key("Title").string(var_1076.as_str());
}
if let Some(var_1077) = &input.source_parameter_name {
object.key("SourceParameterName").string(var_1077.as_str());
}
if let Some(var_1078) = &input.display_options {
#[allow(unused_mut)]
let mut object_1079 = object.key("DisplayOptions").start_object();
crate::json_ser::serialize_structure_crate_model_text_field_control_display_options(
&mut object_1079,
var_1078,
)?;
object_1079.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_parameter_text_area_control(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParameterTextAreaControl,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1080) = &input.parameter_control_id {
object.key("ParameterControlId").string(var_1080.as_str());
}
if let Some(var_1081) = &input.title {
object.key("Title").string(var_1081.as_str());
}
if let Some(var_1082) = &input.source_parameter_name {
object.key("SourceParameterName").string(var_1082.as_str());
}
if let Some(var_1083) = &input.delimiter {
object.key("Delimiter").string(var_1083.as_str());
}
if let Some(var_1084) = &input.display_options {
#[allow(unused_mut)]
let mut object_1085 = object.key("DisplayOptions").start_object();
crate::json_ser::serialize_structure_crate_model_text_area_control_display_options(
&mut object_1085,
var_1084,
)?;
object_1085.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_parameter_slider_control(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParameterSliderControl,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1086) = &input.parameter_control_id {
object.key("ParameterControlId").string(var_1086.as_str());
}
if let Some(var_1087) = &input.title {
object.key("Title").string(var_1087.as_str());
}
if let Some(var_1088) = &input.source_parameter_name {
object.key("SourceParameterName").string(var_1088.as_str());
}
if let Some(var_1089) = &input.display_options {
#[allow(unused_mut)]
let mut object_1090 = object.key("DisplayOptions").start_object();
crate::json_ser::serialize_structure_crate_model_slider_control_display_options(
&mut object_1090,
var_1089,
)?;
object_1090.finish();
}
{
object.key("MaximumValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.maximum_value).into()),
);
}
{
object.key("MinimumValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.minimum_value).into()),
);
}
{
object.key("StepSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.step_size).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_date_time_picker_control(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterDateTimePickerControl,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1091) = &input.filter_control_id {
object.key("FilterControlId").string(var_1091.as_str());
}
if let Some(var_1092) = &input.title {
object.key("Title").string(var_1092.as_str());
}
if let Some(var_1093) = &input.source_filter_id {
object.key("SourceFilterId").string(var_1093.as_str());
}
if let Some(var_1094) = &input.display_options {
#[allow(unused_mut)]
let mut object_1095 = object.key("DisplayOptions").start_object();
crate::json_ser::serialize_structure_crate_model_date_time_picker_control_display_options(
&mut object_1095,
var_1094,
)?;
object_1095.finish();
}
if let Some(var_1096) = &input.r#type {
object.key("Type").string(var_1096.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_list_control(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterListControl,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1097) = &input.filter_control_id {
object.key("FilterControlId").string(var_1097.as_str());
}
if let Some(var_1098) = &input.title {
object.key("Title").string(var_1098.as_str());
}
if let Some(var_1099) = &input.source_filter_id {
object.key("SourceFilterId").string(var_1099.as_str());
}
if let Some(var_1100) = &input.display_options {
#[allow(unused_mut)]
let mut object_1101 = object.key("DisplayOptions").start_object();
crate::json_ser::serialize_structure_crate_model_list_control_display_options(
&mut object_1101,
var_1100,
)?;
object_1101.finish();
}
if let Some(var_1102) = &input.r#type {
object.key("Type").string(var_1102.as_str());
}
if let Some(var_1103) = &input.selectable_values {
#[allow(unused_mut)]
let mut object_1104 = object.key("SelectableValues").start_object();
crate::json_ser::serialize_structure_crate_model_filter_selectable_values(
&mut object_1104,
var_1103,
)?;
object_1104.finish();
}
if let Some(var_1105) = &input.cascading_control_configuration {
#[allow(unused_mut)]
let mut object_1106 = object.key("CascadingControlConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_cascading_control_configuration(
&mut object_1106,
var_1105,
)?;
object_1106.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_drop_down_control(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterDropDownControl,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1107) = &input.filter_control_id {
object.key("FilterControlId").string(var_1107.as_str());
}
if let Some(var_1108) = &input.title {
object.key("Title").string(var_1108.as_str());
}
if let Some(var_1109) = &input.source_filter_id {
object.key("SourceFilterId").string(var_1109.as_str());
}
if let Some(var_1110) = &input.display_options {
#[allow(unused_mut)]
let mut object_1111 = object.key("DisplayOptions").start_object();
crate::json_ser::serialize_structure_crate_model_drop_down_control_display_options(
&mut object_1111,
var_1110,
)?;
object_1111.finish();
}
if let Some(var_1112) = &input.r#type {
object.key("Type").string(var_1112.as_str());
}
if let Some(var_1113) = &input.selectable_values {
#[allow(unused_mut)]
let mut object_1114 = object.key("SelectableValues").start_object();
crate::json_ser::serialize_structure_crate_model_filter_selectable_values(
&mut object_1114,
var_1113,
)?;
object_1114.finish();
}
if let Some(var_1115) = &input.cascading_control_configuration {
#[allow(unused_mut)]
let mut object_1116 = object.key("CascadingControlConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_cascading_control_configuration(
&mut object_1116,
var_1115,
)?;
object_1116.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_text_field_control(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterTextFieldControl,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1117) = &input.filter_control_id {
object.key("FilterControlId").string(var_1117.as_str());
}
if let Some(var_1118) = &input.title {
object.key("Title").string(var_1118.as_str());
}
if let Some(var_1119) = &input.source_filter_id {
object.key("SourceFilterId").string(var_1119.as_str());
}
if let Some(var_1120) = &input.display_options {
#[allow(unused_mut)]
let mut object_1121 = object.key("DisplayOptions").start_object();
crate::json_ser::serialize_structure_crate_model_text_field_control_display_options(
&mut object_1121,
var_1120,
)?;
object_1121.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_text_area_control(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterTextAreaControl,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1122) = &input.filter_control_id {
object.key("FilterControlId").string(var_1122.as_str());
}
if let Some(var_1123) = &input.title {
object.key("Title").string(var_1123.as_str());
}
if let Some(var_1124) = &input.source_filter_id {
object.key("SourceFilterId").string(var_1124.as_str());
}
if let Some(var_1125) = &input.delimiter {
object.key("Delimiter").string(var_1125.as_str());
}
if let Some(var_1126) = &input.display_options {
#[allow(unused_mut)]
let mut object_1127 = object.key("DisplayOptions").start_object();
crate::json_ser::serialize_structure_crate_model_text_area_control_display_options(
&mut object_1127,
var_1126,
)?;
object_1127.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_slider_control(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterSliderControl,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1128) = &input.filter_control_id {
object.key("FilterControlId").string(var_1128.as_str());
}
if let Some(var_1129) = &input.title {
object.key("Title").string(var_1129.as_str());
}
if let Some(var_1130) = &input.source_filter_id {
object.key("SourceFilterId").string(var_1130.as_str());
}
if let Some(var_1131) = &input.display_options {
#[allow(unused_mut)]
let mut object_1132 = object.key("DisplayOptions").start_object();
crate::json_ser::serialize_structure_crate_model_slider_control_display_options(
&mut object_1132,
var_1131,
)?;
object_1132.finish();
}
if let Some(var_1133) = &input.r#type {
object.key("Type").string(var_1133.as_str());
}
{
object.key("MaximumValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.maximum_value).into()),
);
}
{
object.key("MinimumValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.minimum_value).into()),
);
}
{
object.key("StepSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.step_size).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_relative_date_time_control(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterRelativeDateTimeControl,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1134) = &input.filter_control_id {
object.key("FilterControlId").string(var_1134.as_str());
}
if let Some(var_1135) = &input.title {
object.key("Title").string(var_1135.as_str());
}
if let Some(var_1136) = &input.source_filter_id {
object.key("SourceFilterId").string(var_1136.as_str());
}
if let Some(var_1137) = &input.display_options {
#[allow(unused_mut)]
let mut object_1138 = object.key("DisplayOptions").start_object();
crate::json_ser::serialize_structure_crate_model_relative_date_time_control_display_options(&mut object_1138, var_1137)?;
object_1138.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_table_visual(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableVisual,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1139) = &input.visual_id {
object.key("VisualId").string(var_1139.as_str());
}
if let Some(var_1140) = &input.title {
#[allow(unused_mut)]
let mut object_1141 = object.key("Title").start_object();
crate::json_ser::serialize_structure_crate_model_visual_title_label_options(
&mut object_1141,
var_1140,
)?;
object_1141.finish();
}
if let Some(var_1142) = &input.subtitle {
#[allow(unused_mut)]
let mut object_1143 = object.key("Subtitle").start_object();
crate::json_ser::serialize_structure_crate_model_visual_subtitle_label_options(
&mut object_1143,
var_1142,
)?;
object_1143.finish();
}
if let Some(var_1144) = &input.chart_configuration {
#[allow(unused_mut)]
let mut object_1145 = object.key("ChartConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_table_configuration(
&mut object_1145,
var_1144,
)?;
object_1145.finish();
}
if let Some(var_1146) = &input.conditional_formatting {
#[allow(unused_mut)]
let mut object_1147 = object.key("ConditionalFormatting").start_object();
crate::json_ser::serialize_structure_crate_model_table_conditional_formatting(
&mut object_1147,
var_1146,
)?;
object_1147.finish();
}
if let Some(var_1148) = &input.actions {
let mut array_1149 = object.key("Actions").start_array();
for item_1150 in var_1148 {
{
#[allow(unused_mut)]
let mut object_1151 = array_1149.value().start_object();
crate::json_ser::serialize_structure_crate_model_visual_custom_action(
&mut object_1151,
item_1150,
)?;
object_1151.finish();
}
}
array_1149.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pivot_table_visual(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PivotTableVisual,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1152) = &input.visual_id {
object.key("VisualId").string(var_1152.as_str());
}
if let Some(var_1153) = &input.title {
#[allow(unused_mut)]
let mut object_1154 = object.key("Title").start_object();
crate::json_ser::serialize_structure_crate_model_visual_title_label_options(
&mut object_1154,
var_1153,
)?;
object_1154.finish();
}
if let Some(var_1155) = &input.subtitle {
#[allow(unused_mut)]
let mut object_1156 = object.key("Subtitle").start_object();
crate::json_ser::serialize_structure_crate_model_visual_subtitle_label_options(
&mut object_1156,
var_1155,
)?;
object_1156.finish();
}
if let Some(var_1157) = &input.chart_configuration {
#[allow(unused_mut)]
let mut object_1158 = object.key("ChartConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_pivot_table_configuration(
&mut object_1158,
var_1157,
)?;
object_1158.finish();
}
if let Some(var_1159) = &input.conditional_formatting {
#[allow(unused_mut)]
let mut object_1160 = object.key("ConditionalFormatting").start_object();
crate::json_ser::serialize_structure_crate_model_pivot_table_conditional_formatting(
&mut object_1160,
var_1159,
)?;
object_1160.finish();
}
if let Some(var_1161) = &input.actions {
let mut array_1162 = object.key("Actions").start_array();
for item_1163 in var_1161 {
{
#[allow(unused_mut)]
let mut object_1164 = array_1162.value().start_object();
crate::json_ser::serialize_structure_crate_model_visual_custom_action(
&mut object_1164,
item_1163,
)?;
object_1164.finish();
}
}
array_1162.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_bar_chart_visual(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BarChartVisual,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1165) = &input.visual_id {
object.key("VisualId").string(var_1165.as_str());
}
if let Some(var_1166) = &input.title {
#[allow(unused_mut)]
let mut object_1167 = object.key("Title").start_object();
crate::json_ser::serialize_structure_crate_model_visual_title_label_options(
&mut object_1167,
var_1166,
)?;
object_1167.finish();
}
if let Some(var_1168) = &input.subtitle {
#[allow(unused_mut)]
let mut object_1169 = object.key("Subtitle").start_object();
crate::json_ser::serialize_structure_crate_model_visual_subtitle_label_options(
&mut object_1169,
var_1168,
)?;
object_1169.finish();
}
if let Some(var_1170) = &input.chart_configuration {
#[allow(unused_mut)]
let mut object_1171 = object.key("ChartConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_bar_chart_configuration(
&mut object_1171,
var_1170,
)?;
object_1171.finish();
}
if let Some(var_1172) = &input.actions {
let mut array_1173 = object.key("Actions").start_array();
for item_1174 in var_1172 {
{
#[allow(unused_mut)]
let mut object_1175 = array_1173.value().start_object();
crate::json_ser::serialize_structure_crate_model_visual_custom_action(
&mut object_1175,
item_1174,
)?;
object_1175.finish();
}
}
array_1173.finish();
}
if let Some(var_1176) = &input.column_hierarchies {
let mut array_1177 = object.key("ColumnHierarchies").start_array();
for item_1178 in var_1176 {
{
#[allow(unused_mut)]
let mut object_1179 = array_1177.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_hierarchy(
&mut object_1179,
item_1178,
)?;
object_1179.finish();
}
}
array_1177.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_kpi_visual(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KpiVisual,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1180) = &input.visual_id {
object.key("VisualId").string(var_1180.as_str());
}
if let Some(var_1181) = &input.title {
#[allow(unused_mut)]
let mut object_1182 = object.key("Title").start_object();
crate::json_ser::serialize_structure_crate_model_visual_title_label_options(
&mut object_1182,
var_1181,
)?;
object_1182.finish();
}
if let Some(var_1183) = &input.subtitle {
#[allow(unused_mut)]
let mut object_1184 = object.key("Subtitle").start_object();
crate::json_ser::serialize_structure_crate_model_visual_subtitle_label_options(
&mut object_1184,
var_1183,
)?;
object_1184.finish();
}
if let Some(var_1185) = &input.chart_configuration {
#[allow(unused_mut)]
let mut object_1186 = object.key("ChartConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_kpi_configuration(
&mut object_1186,
var_1185,
)?;
object_1186.finish();
}
if let Some(var_1187) = &input.conditional_formatting {
#[allow(unused_mut)]
let mut object_1188 = object.key("ConditionalFormatting").start_object();
crate::json_ser::serialize_structure_crate_model_kpi_conditional_formatting(
&mut object_1188,
var_1187,
)?;
object_1188.finish();
}
if let Some(var_1189) = &input.actions {
let mut array_1190 = object.key("Actions").start_array();
for item_1191 in var_1189 {
{
#[allow(unused_mut)]
let mut object_1192 = array_1190.value().start_object();
crate::json_ser::serialize_structure_crate_model_visual_custom_action(
&mut object_1192,
item_1191,
)?;
object_1192.finish();
}
}
array_1190.finish();
}
if let Some(var_1193) = &input.column_hierarchies {
let mut array_1194 = object.key("ColumnHierarchies").start_array();
for item_1195 in var_1193 {
{
#[allow(unused_mut)]
let mut object_1196 = array_1194.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_hierarchy(
&mut object_1196,
item_1195,
)?;
object_1196.finish();
}
}
array_1194.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pie_chart_visual(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PieChartVisual,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1197) = &input.visual_id {
object.key("VisualId").string(var_1197.as_str());
}
if let Some(var_1198) = &input.title {
#[allow(unused_mut)]
let mut object_1199 = object.key("Title").start_object();
crate::json_ser::serialize_structure_crate_model_visual_title_label_options(
&mut object_1199,
var_1198,
)?;
object_1199.finish();
}
if let Some(var_1200) = &input.subtitle {
#[allow(unused_mut)]
let mut object_1201 = object.key("Subtitle").start_object();
crate::json_ser::serialize_structure_crate_model_visual_subtitle_label_options(
&mut object_1201,
var_1200,
)?;
object_1201.finish();
}
if let Some(var_1202) = &input.chart_configuration {
#[allow(unused_mut)]
let mut object_1203 = object.key("ChartConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_pie_chart_configuration(
&mut object_1203,
var_1202,
)?;
object_1203.finish();
}
if let Some(var_1204) = &input.actions {
let mut array_1205 = object.key("Actions").start_array();
for item_1206 in var_1204 {
{
#[allow(unused_mut)]
let mut object_1207 = array_1205.value().start_object();
crate::json_ser::serialize_structure_crate_model_visual_custom_action(
&mut object_1207,
item_1206,
)?;
object_1207.finish();
}
}
array_1205.finish();
}
if let Some(var_1208) = &input.column_hierarchies {
let mut array_1209 = object.key("ColumnHierarchies").start_array();
for item_1210 in var_1208 {
{
#[allow(unused_mut)]
let mut object_1211 = array_1209.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_hierarchy(
&mut object_1211,
item_1210,
)?;
object_1211.finish();
}
}
array_1209.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_gauge_chart_visual(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GaugeChartVisual,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1212) = &input.visual_id {
object.key("VisualId").string(var_1212.as_str());
}
if let Some(var_1213) = &input.title {
#[allow(unused_mut)]
let mut object_1214 = object.key("Title").start_object();
crate::json_ser::serialize_structure_crate_model_visual_title_label_options(
&mut object_1214,
var_1213,
)?;
object_1214.finish();
}
if let Some(var_1215) = &input.subtitle {
#[allow(unused_mut)]
let mut object_1216 = object.key("Subtitle").start_object();
crate::json_ser::serialize_structure_crate_model_visual_subtitle_label_options(
&mut object_1216,
var_1215,
)?;
object_1216.finish();
}
if let Some(var_1217) = &input.chart_configuration {
#[allow(unused_mut)]
let mut object_1218 = object.key("ChartConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_gauge_chart_configuration(
&mut object_1218,
var_1217,
)?;
object_1218.finish();
}
if let Some(var_1219) = &input.conditional_formatting {
#[allow(unused_mut)]
let mut object_1220 = object.key("ConditionalFormatting").start_object();
crate::json_ser::serialize_structure_crate_model_gauge_chart_conditional_formatting(
&mut object_1220,
var_1219,
)?;
object_1220.finish();
}
if let Some(var_1221) = &input.actions {
let mut array_1222 = object.key("Actions").start_array();
for item_1223 in var_1221 {
{
#[allow(unused_mut)]
let mut object_1224 = array_1222.value().start_object();
crate::json_ser::serialize_structure_crate_model_visual_custom_action(
&mut object_1224,
item_1223,
)?;
object_1224.finish();
}
}
array_1222.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_line_chart_visual(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LineChartVisual,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1225) = &input.visual_id {
object.key("VisualId").string(var_1225.as_str());
}
if let Some(var_1226) = &input.title {
#[allow(unused_mut)]
let mut object_1227 = object.key("Title").start_object();
crate::json_ser::serialize_structure_crate_model_visual_title_label_options(
&mut object_1227,
var_1226,
)?;
object_1227.finish();
}
if let Some(var_1228) = &input.subtitle {
#[allow(unused_mut)]
let mut object_1229 = object.key("Subtitle").start_object();
crate::json_ser::serialize_structure_crate_model_visual_subtitle_label_options(
&mut object_1229,
var_1228,
)?;
object_1229.finish();
}
if let Some(var_1230) = &input.chart_configuration {
#[allow(unused_mut)]
let mut object_1231 = object.key("ChartConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_line_chart_configuration(
&mut object_1231,
var_1230,
)?;
object_1231.finish();
}
if let Some(var_1232) = &input.actions {
let mut array_1233 = object.key("Actions").start_array();
for item_1234 in var_1232 {
{
#[allow(unused_mut)]
let mut object_1235 = array_1233.value().start_object();
crate::json_ser::serialize_structure_crate_model_visual_custom_action(
&mut object_1235,
item_1234,
)?;
object_1235.finish();
}
}
array_1233.finish();
}
if let Some(var_1236) = &input.column_hierarchies {
let mut array_1237 = object.key("ColumnHierarchies").start_array();
for item_1238 in var_1236 {
{
#[allow(unused_mut)]
let mut object_1239 = array_1237.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_hierarchy(
&mut object_1239,
item_1238,
)?;
object_1239.finish();
}
}
array_1237.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_heat_map_visual(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HeatMapVisual,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1240) = &input.visual_id {
object.key("VisualId").string(var_1240.as_str());
}
if let Some(var_1241) = &input.title {
#[allow(unused_mut)]
let mut object_1242 = object.key("Title").start_object();
crate::json_ser::serialize_structure_crate_model_visual_title_label_options(
&mut object_1242,
var_1241,
)?;
object_1242.finish();
}
if let Some(var_1243) = &input.subtitle {
#[allow(unused_mut)]
let mut object_1244 = object.key("Subtitle").start_object();
crate::json_ser::serialize_structure_crate_model_visual_subtitle_label_options(
&mut object_1244,
var_1243,
)?;
object_1244.finish();
}
if let Some(var_1245) = &input.chart_configuration {
#[allow(unused_mut)]
let mut object_1246 = object.key("ChartConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_heat_map_configuration(
&mut object_1246,
var_1245,
)?;
object_1246.finish();
}
if let Some(var_1247) = &input.column_hierarchies {
let mut array_1248 = object.key("ColumnHierarchies").start_array();
for item_1249 in var_1247 {
{
#[allow(unused_mut)]
let mut object_1250 = array_1248.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_hierarchy(
&mut object_1250,
item_1249,
)?;
object_1250.finish();
}
}
array_1248.finish();
}
if let Some(var_1251) = &input.actions {
let mut array_1252 = object.key("Actions").start_array();
for item_1253 in var_1251 {
{
#[allow(unused_mut)]
let mut object_1254 = array_1252.value().start_object();
crate::json_ser::serialize_structure_crate_model_visual_custom_action(
&mut object_1254,
item_1253,
)?;
object_1254.finish();
}
}
array_1252.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tree_map_visual(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TreeMapVisual,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1255) = &input.visual_id {
object.key("VisualId").string(var_1255.as_str());
}
if let Some(var_1256) = &input.title {
#[allow(unused_mut)]
let mut object_1257 = object.key("Title").start_object();
crate::json_ser::serialize_structure_crate_model_visual_title_label_options(
&mut object_1257,
var_1256,
)?;
object_1257.finish();
}
if let Some(var_1258) = &input.subtitle {
#[allow(unused_mut)]
let mut object_1259 = object.key("Subtitle").start_object();
crate::json_ser::serialize_structure_crate_model_visual_subtitle_label_options(
&mut object_1259,
var_1258,
)?;
object_1259.finish();
}
if let Some(var_1260) = &input.chart_configuration {
#[allow(unused_mut)]
let mut object_1261 = object.key("ChartConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_tree_map_configuration(
&mut object_1261,
var_1260,
)?;
object_1261.finish();
}
if let Some(var_1262) = &input.actions {
let mut array_1263 = object.key("Actions").start_array();
for item_1264 in var_1262 {
{
#[allow(unused_mut)]
let mut object_1265 = array_1263.value().start_object();
crate::json_ser::serialize_structure_crate_model_visual_custom_action(
&mut object_1265,
item_1264,
)?;
object_1265.finish();
}
}
array_1263.finish();
}
if let Some(var_1266) = &input.column_hierarchies {
let mut array_1267 = object.key("ColumnHierarchies").start_array();
for item_1268 in var_1266 {
{
#[allow(unused_mut)]
let mut object_1269 = array_1267.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_hierarchy(
&mut object_1269,
item_1268,
)?;
object_1269.finish();
}
}
array_1267.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_geospatial_map_visual(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GeospatialMapVisual,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1270) = &input.visual_id {
object.key("VisualId").string(var_1270.as_str());
}
if let Some(var_1271) = &input.title {
#[allow(unused_mut)]
let mut object_1272 = object.key("Title").start_object();
crate::json_ser::serialize_structure_crate_model_visual_title_label_options(
&mut object_1272,
var_1271,
)?;
object_1272.finish();
}
if let Some(var_1273) = &input.subtitle {
#[allow(unused_mut)]
let mut object_1274 = object.key("Subtitle").start_object();
crate::json_ser::serialize_structure_crate_model_visual_subtitle_label_options(
&mut object_1274,
var_1273,
)?;
object_1274.finish();
}
if let Some(var_1275) = &input.chart_configuration {
#[allow(unused_mut)]
let mut object_1276 = object.key("ChartConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_geospatial_map_configuration(
&mut object_1276,
var_1275,
)?;
object_1276.finish();
}
if let Some(var_1277) = &input.column_hierarchies {
let mut array_1278 = object.key("ColumnHierarchies").start_array();
for item_1279 in var_1277 {
{
#[allow(unused_mut)]
let mut object_1280 = array_1278.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_hierarchy(
&mut object_1280,
item_1279,
)?;
object_1280.finish();
}
}
array_1278.finish();
}
if let Some(var_1281) = &input.actions {
let mut array_1282 = object.key("Actions").start_array();
for item_1283 in var_1281 {
{
#[allow(unused_mut)]
let mut object_1284 = array_1282.value().start_object();
crate::json_ser::serialize_structure_crate_model_visual_custom_action(
&mut object_1284,
item_1283,
)?;
object_1284.finish();
}
}
array_1282.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filled_map_visual(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilledMapVisual,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1285) = &input.visual_id {
object.key("VisualId").string(var_1285.as_str());
}
if let Some(var_1286) = &input.title {
#[allow(unused_mut)]
let mut object_1287 = object.key("Title").start_object();
crate::json_ser::serialize_structure_crate_model_visual_title_label_options(
&mut object_1287,
var_1286,
)?;
object_1287.finish();
}
if let Some(var_1288) = &input.subtitle {
#[allow(unused_mut)]
let mut object_1289 = object.key("Subtitle").start_object();
crate::json_ser::serialize_structure_crate_model_visual_subtitle_label_options(
&mut object_1289,
var_1288,
)?;
object_1289.finish();
}
if let Some(var_1290) = &input.chart_configuration {
#[allow(unused_mut)]
let mut object_1291 = object.key("ChartConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_filled_map_configuration(
&mut object_1291,
var_1290,
)?;
object_1291.finish();
}
if let Some(var_1292) = &input.conditional_formatting {
#[allow(unused_mut)]
let mut object_1293 = object.key("ConditionalFormatting").start_object();
crate::json_ser::serialize_structure_crate_model_filled_map_conditional_formatting(
&mut object_1293,
var_1292,
)?;
object_1293.finish();
}
if let Some(var_1294) = &input.column_hierarchies {
let mut array_1295 = object.key("ColumnHierarchies").start_array();
for item_1296 in var_1294 {
{
#[allow(unused_mut)]
let mut object_1297 = array_1295.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_hierarchy(
&mut object_1297,
item_1296,
)?;
object_1297.finish();
}
}
array_1295.finish();
}
if let Some(var_1298) = &input.actions {
let mut array_1299 = object.key("Actions").start_array();
for item_1300 in var_1298 {
{
#[allow(unused_mut)]
let mut object_1301 = array_1299.value().start_object();
crate::json_ser::serialize_structure_crate_model_visual_custom_action(
&mut object_1301,
item_1300,
)?;
object_1301.finish();
}
}
array_1299.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_funnel_chart_visual(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FunnelChartVisual,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1302) = &input.visual_id {
object.key("VisualId").string(var_1302.as_str());
}
if let Some(var_1303) = &input.title {
#[allow(unused_mut)]
let mut object_1304 = object.key("Title").start_object();
crate::json_ser::serialize_structure_crate_model_visual_title_label_options(
&mut object_1304,
var_1303,
)?;
object_1304.finish();
}
if let Some(var_1305) = &input.subtitle {
#[allow(unused_mut)]
let mut object_1306 = object.key("Subtitle").start_object();
crate::json_ser::serialize_structure_crate_model_visual_subtitle_label_options(
&mut object_1306,
var_1305,
)?;
object_1306.finish();
}
if let Some(var_1307) = &input.chart_configuration {
#[allow(unused_mut)]
let mut object_1308 = object.key("ChartConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_funnel_chart_configuration(
&mut object_1308,
var_1307,
)?;
object_1308.finish();
}
if let Some(var_1309) = &input.actions {
let mut array_1310 = object.key("Actions").start_array();
for item_1311 in var_1309 {
{
#[allow(unused_mut)]
let mut object_1312 = array_1310.value().start_object();
crate::json_ser::serialize_structure_crate_model_visual_custom_action(
&mut object_1312,
item_1311,
)?;
object_1312.finish();
}
}
array_1310.finish();
}
if let Some(var_1313) = &input.column_hierarchies {
let mut array_1314 = object.key("ColumnHierarchies").start_array();
for item_1315 in var_1313 {
{
#[allow(unused_mut)]
let mut object_1316 = array_1314.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_hierarchy(
&mut object_1316,
item_1315,
)?;
object_1316.finish();
}
}
array_1314.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_scatter_plot_visual(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ScatterPlotVisual,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1317) = &input.visual_id {
object.key("VisualId").string(var_1317.as_str());
}
if let Some(var_1318) = &input.title {
#[allow(unused_mut)]
let mut object_1319 = object.key("Title").start_object();
crate::json_ser::serialize_structure_crate_model_visual_title_label_options(
&mut object_1319,
var_1318,
)?;
object_1319.finish();
}
if let Some(var_1320) = &input.subtitle {
#[allow(unused_mut)]
let mut object_1321 = object.key("Subtitle").start_object();
crate::json_ser::serialize_structure_crate_model_visual_subtitle_label_options(
&mut object_1321,
var_1320,
)?;
object_1321.finish();
}
if let Some(var_1322) = &input.chart_configuration {
#[allow(unused_mut)]
let mut object_1323 = object.key("ChartConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_scatter_plot_configuration(
&mut object_1323,
var_1322,
)?;
object_1323.finish();
}
if let Some(var_1324) = &input.actions {
let mut array_1325 = object.key("Actions").start_array();
for item_1326 in var_1324 {
{
#[allow(unused_mut)]
let mut object_1327 = array_1325.value().start_object();
crate::json_ser::serialize_structure_crate_model_visual_custom_action(
&mut object_1327,
item_1326,
)?;
object_1327.finish();
}
}
array_1325.finish();
}
if let Some(var_1328) = &input.column_hierarchies {
let mut array_1329 = object.key("ColumnHierarchies").start_array();
for item_1330 in var_1328 {
{
#[allow(unused_mut)]
let mut object_1331 = array_1329.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_hierarchy(
&mut object_1331,
item_1330,
)?;
object_1331.finish();
}
}
array_1329.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_combo_chart_visual(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComboChartVisual,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1332) = &input.visual_id {
object.key("VisualId").string(var_1332.as_str());
}
if let Some(var_1333) = &input.title {
#[allow(unused_mut)]
let mut object_1334 = object.key("Title").start_object();
crate::json_ser::serialize_structure_crate_model_visual_title_label_options(
&mut object_1334,
var_1333,
)?;
object_1334.finish();
}
if let Some(var_1335) = &input.subtitle {
#[allow(unused_mut)]
let mut object_1336 = object.key("Subtitle").start_object();
crate::json_ser::serialize_structure_crate_model_visual_subtitle_label_options(
&mut object_1336,
var_1335,
)?;
object_1336.finish();
}
if let Some(var_1337) = &input.chart_configuration {
#[allow(unused_mut)]
let mut object_1338 = object.key("ChartConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_combo_chart_configuration(
&mut object_1338,
var_1337,
)?;
object_1338.finish();
}
if let Some(var_1339) = &input.actions {
let mut array_1340 = object.key("Actions").start_array();
for item_1341 in var_1339 {
{
#[allow(unused_mut)]
let mut object_1342 = array_1340.value().start_object();
crate::json_ser::serialize_structure_crate_model_visual_custom_action(
&mut object_1342,
item_1341,
)?;
object_1342.finish();
}
}
array_1340.finish();
}
if let Some(var_1343) = &input.column_hierarchies {
let mut array_1344 = object.key("ColumnHierarchies").start_array();
for item_1345 in var_1343 {
{
#[allow(unused_mut)]
let mut object_1346 = array_1344.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_hierarchy(
&mut object_1346,
item_1345,
)?;
object_1346.finish();
}
}
array_1344.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_box_plot_visual(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BoxPlotVisual,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1347) = &input.visual_id {
object.key("VisualId").string(var_1347.as_str());
}
if let Some(var_1348) = &input.title {
#[allow(unused_mut)]
let mut object_1349 = object.key("Title").start_object();
crate::json_ser::serialize_structure_crate_model_visual_title_label_options(
&mut object_1349,
var_1348,
)?;
object_1349.finish();
}
if let Some(var_1350) = &input.subtitle {
#[allow(unused_mut)]
let mut object_1351 = object.key("Subtitle").start_object();
crate::json_ser::serialize_structure_crate_model_visual_subtitle_label_options(
&mut object_1351,
var_1350,
)?;
object_1351.finish();
}
if let Some(var_1352) = &input.chart_configuration {
#[allow(unused_mut)]
let mut object_1353 = object.key("ChartConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_box_plot_chart_configuration(
&mut object_1353,
var_1352,
)?;
object_1353.finish();
}
if let Some(var_1354) = &input.actions {
let mut array_1355 = object.key("Actions").start_array();
for item_1356 in var_1354 {
{
#[allow(unused_mut)]
let mut object_1357 = array_1355.value().start_object();
crate::json_ser::serialize_structure_crate_model_visual_custom_action(
&mut object_1357,
item_1356,
)?;
object_1357.finish();
}
}
array_1355.finish();
}
if let Some(var_1358) = &input.column_hierarchies {
let mut array_1359 = object.key("ColumnHierarchies").start_array();
for item_1360 in var_1358 {
{
#[allow(unused_mut)]
let mut object_1361 = array_1359.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_hierarchy(
&mut object_1361,
item_1360,
)?;
object_1361.finish();
}
}
array_1359.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_waterfall_visual(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WaterfallVisual,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1362) = &input.visual_id {
object.key("VisualId").string(var_1362.as_str());
}
if let Some(var_1363) = &input.title {
#[allow(unused_mut)]
let mut object_1364 = object.key("Title").start_object();
crate::json_ser::serialize_structure_crate_model_visual_title_label_options(
&mut object_1364,
var_1363,
)?;
object_1364.finish();
}
if let Some(var_1365) = &input.subtitle {
#[allow(unused_mut)]
let mut object_1366 = object.key("Subtitle").start_object();
crate::json_ser::serialize_structure_crate_model_visual_subtitle_label_options(
&mut object_1366,
var_1365,
)?;
object_1366.finish();
}
if let Some(var_1367) = &input.chart_configuration {
#[allow(unused_mut)]
let mut object_1368 = object.key("ChartConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_waterfall_chart_configuration(
&mut object_1368,
var_1367,
)?;
object_1368.finish();
}
if let Some(var_1369) = &input.actions {
let mut array_1370 = object.key("Actions").start_array();
for item_1371 in var_1369 {
{
#[allow(unused_mut)]
let mut object_1372 = array_1370.value().start_object();
crate::json_ser::serialize_structure_crate_model_visual_custom_action(
&mut object_1372,
item_1371,
)?;
object_1372.finish();
}
}
array_1370.finish();
}
if let Some(var_1373) = &input.column_hierarchies {
let mut array_1374 = object.key("ColumnHierarchies").start_array();
for item_1375 in var_1373 {
{
#[allow(unused_mut)]
let mut object_1376 = array_1374.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_hierarchy(
&mut object_1376,
item_1375,
)?;
object_1376.finish();
}
}
array_1374.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_histogram_visual(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HistogramVisual,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1377) = &input.visual_id {
object.key("VisualId").string(var_1377.as_str());
}
if let Some(var_1378) = &input.title {
#[allow(unused_mut)]
let mut object_1379 = object.key("Title").start_object();
crate::json_ser::serialize_structure_crate_model_visual_title_label_options(
&mut object_1379,
var_1378,
)?;
object_1379.finish();
}
if let Some(var_1380) = &input.subtitle {
#[allow(unused_mut)]
let mut object_1381 = object.key("Subtitle").start_object();
crate::json_ser::serialize_structure_crate_model_visual_subtitle_label_options(
&mut object_1381,
var_1380,
)?;
object_1381.finish();
}
if let Some(var_1382) = &input.chart_configuration {
#[allow(unused_mut)]
let mut object_1383 = object.key("ChartConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_histogram_configuration(
&mut object_1383,
var_1382,
)?;
object_1383.finish();
}
if let Some(var_1384) = &input.actions {
let mut array_1385 = object.key("Actions").start_array();
for item_1386 in var_1384 {
{
#[allow(unused_mut)]
let mut object_1387 = array_1385.value().start_object();
crate::json_ser::serialize_structure_crate_model_visual_custom_action(
&mut object_1387,
item_1386,
)?;
object_1387.finish();
}
}
array_1385.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_word_cloud_visual(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WordCloudVisual,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1388) = &input.visual_id {
object.key("VisualId").string(var_1388.as_str());
}
if let Some(var_1389) = &input.title {
#[allow(unused_mut)]
let mut object_1390 = object.key("Title").start_object();
crate::json_ser::serialize_structure_crate_model_visual_title_label_options(
&mut object_1390,
var_1389,
)?;
object_1390.finish();
}
if let Some(var_1391) = &input.subtitle {
#[allow(unused_mut)]
let mut object_1392 = object.key("Subtitle").start_object();
crate::json_ser::serialize_structure_crate_model_visual_subtitle_label_options(
&mut object_1392,
var_1391,
)?;
object_1392.finish();
}
if let Some(var_1393) = &input.chart_configuration {
#[allow(unused_mut)]
let mut object_1394 = object.key("ChartConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_word_cloud_chart_configuration(
&mut object_1394,
var_1393,
)?;
object_1394.finish();
}
if let Some(var_1395) = &input.actions {
let mut array_1396 = object.key("Actions").start_array();
for item_1397 in var_1395 {
{
#[allow(unused_mut)]
let mut object_1398 = array_1396.value().start_object();
crate::json_ser::serialize_structure_crate_model_visual_custom_action(
&mut object_1398,
item_1397,
)?;
object_1398.finish();
}
}
array_1396.finish();
}
if let Some(var_1399) = &input.column_hierarchies {
let mut array_1400 = object.key("ColumnHierarchies").start_array();
for item_1401 in var_1399 {
{
#[allow(unused_mut)]
let mut object_1402 = array_1400.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_hierarchy(
&mut object_1402,
item_1401,
)?;
object_1402.finish();
}
}
array_1400.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_insight_visual(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InsightVisual,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1403) = &input.visual_id {
object.key("VisualId").string(var_1403.as_str());
}
if let Some(var_1404) = &input.title {
#[allow(unused_mut)]
let mut object_1405 = object.key("Title").start_object();
crate::json_ser::serialize_structure_crate_model_visual_title_label_options(
&mut object_1405,
var_1404,
)?;
object_1405.finish();
}
if let Some(var_1406) = &input.subtitle {
#[allow(unused_mut)]
let mut object_1407 = object.key("Subtitle").start_object();
crate::json_ser::serialize_structure_crate_model_visual_subtitle_label_options(
&mut object_1407,
var_1406,
)?;
object_1407.finish();
}
if let Some(var_1408) = &input.insight_configuration {
#[allow(unused_mut)]
let mut object_1409 = object.key("InsightConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_insight_configuration(
&mut object_1409,
var_1408,
)?;
object_1409.finish();
}
if let Some(var_1410) = &input.actions {
let mut array_1411 = object.key("Actions").start_array();
for item_1412 in var_1410 {
{
#[allow(unused_mut)]
let mut object_1413 = array_1411.value().start_object();
crate::json_ser::serialize_structure_crate_model_visual_custom_action(
&mut object_1413,
item_1412,
)?;
object_1413.finish();
}
}
array_1411.finish();
}
if let Some(var_1414) = &input.data_set_identifier {
object.key("DataSetIdentifier").string(var_1414.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sankey_diagram_visual(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SankeyDiagramVisual,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1415) = &input.visual_id {
object.key("VisualId").string(var_1415.as_str());
}
if let Some(var_1416) = &input.title {
#[allow(unused_mut)]
let mut object_1417 = object.key("Title").start_object();
crate::json_ser::serialize_structure_crate_model_visual_title_label_options(
&mut object_1417,
var_1416,
)?;
object_1417.finish();
}
if let Some(var_1418) = &input.subtitle {
#[allow(unused_mut)]
let mut object_1419 = object.key("Subtitle").start_object();
crate::json_ser::serialize_structure_crate_model_visual_subtitle_label_options(
&mut object_1419,
var_1418,
)?;
object_1419.finish();
}
if let Some(var_1420) = &input.chart_configuration {
#[allow(unused_mut)]
let mut object_1421 = object.key("ChartConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_sankey_diagram_chart_configuration(
&mut object_1421,
var_1420,
)?;
object_1421.finish();
}
if let Some(var_1422) = &input.actions {
let mut array_1423 = object.key("Actions").start_array();
for item_1424 in var_1422 {
{
#[allow(unused_mut)]
let mut object_1425 = array_1423.value().start_object();
crate::json_ser::serialize_structure_crate_model_visual_custom_action(
&mut object_1425,
item_1424,
)?;
object_1425.finish();
}
}
array_1423.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_content_visual(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomContentVisual,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1426) = &input.visual_id {
object.key("VisualId").string(var_1426.as_str());
}
if let Some(var_1427) = &input.title {
#[allow(unused_mut)]
let mut object_1428 = object.key("Title").start_object();
crate::json_ser::serialize_structure_crate_model_visual_title_label_options(
&mut object_1428,
var_1427,
)?;
object_1428.finish();
}
if let Some(var_1429) = &input.subtitle {
#[allow(unused_mut)]
let mut object_1430 = object.key("Subtitle").start_object();
crate::json_ser::serialize_structure_crate_model_visual_subtitle_label_options(
&mut object_1430,
var_1429,
)?;
object_1430.finish();
}
if let Some(var_1431) = &input.chart_configuration {
#[allow(unused_mut)]
let mut object_1432 = object.key("ChartConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_custom_content_configuration(
&mut object_1432,
var_1431,
)?;
object_1432.finish();
}
if let Some(var_1433) = &input.actions {
let mut array_1434 = object.key("Actions").start_array();
for item_1435 in var_1433 {
{
#[allow(unused_mut)]
let mut object_1436 = array_1434.value().start_object();
crate::json_ser::serialize_structure_crate_model_visual_custom_action(
&mut object_1436,
item_1435,
)?;
object_1436.finish();
}
}
array_1434.finish();
}
if let Some(var_1437) = &input.data_set_identifier {
object.key("DataSetIdentifier").string(var_1437.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_empty_visual(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EmptyVisual,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1438) = &input.visual_id {
object.key("VisualId").string(var_1438.as_str());
}
if let Some(var_1439) = &input.data_set_identifier {
object.key("DataSetIdentifier").string(var_1439.as_str());
}
if let Some(var_1440) = &input.actions {
let mut array_1441 = object.key("Actions").start_array();
for item_1442 in var_1440 {
{
#[allow(unused_mut)]
let mut object_1443 = array_1441.value().start_object();
crate::json_ser::serialize_structure_crate_model_visual_custom_action(
&mut object_1443,
item_1442,
)?;
object_1443.finish();
}
}
array_1441.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_layout_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LayoutConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1444) = &input.grid_layout {
#[allow(unused_mut)]
let mut object_1445 = object.key("GridLayout").start_object();
crate::json_ser::serialize_structure_crate_model_grid_layout_configuration(
&mut object_1445,
var_1444,
)?;
object_1445.finish();
}
if let Some(var_1446) = &input.free_form_layout {
#[allow(unused_mut)]
let mut object_1447 = object.key("FreeFormLayout").start_object();
crate::json_ser::serialize_structure_crate_model_free_form_layout_configuration(
&mut object_1447,
var_1446,
)?;
object_1447.finish();
}
if let Some(var_1448) = &input.section_based_layout {
#[allow(unused_mut)]
let mut object_1449 = object.key("SectionBasedLayout").start_object();
crate::json_ser::serialize_structure_crate_model_section_based_layout_configuration(
&mut object_1449,
var_1448,
)?;
object_1449.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sheet_control_layout_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SheetControlLayoutConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1450) = &input.grid_layout {
#[allow(unused_mut)]
let mut object_1451 = object.key("GridLayout").start_object();
crate::json_ser::serialize_structure_crate_model_grid_layout_configuration(
&mut object_1451,
var_1450,
)?;
object_1451.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_string_default_values(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StringDefaultValues,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1452) = &input.dynamic_value {
#[allow(unused_mut)]
let mut object_1453 = object.key("DynamicValue").start_object();
crate::json_ser::serialize_structure_crate_model_dynamic_default_value(
&mut object_1453,
var_1452,
)?;
object_1453.finish();
}
if let Some(var_1454) = &input.static_values {
let mut array_1455 = object.key("StaticValues").start_array();
for item_1456 in var_1454 {
{
array_1455.value().string(item_1456.as_str());
}
}
array_1455.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_string_value_when_unset_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StringValueWhenUnsetConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1457) = &input.value_when_unset_option {
object.key("ValueWhenUnsetOption").string(var_1457.as_str());
}
if let Some(var_1458) = &input.custom_value {
object.key("CustomValue").string(var_1458.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_decimal_default_values(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DecimalDefaultValues,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1459) = &input.dynamic_value {
#[allow(unused_mut)]
let mut object_1460 = object.key("DynamicValue").start_object();
crate::json_ser::serialize_structure_crate_model_dynamic_default_value(
&mut object_1460,
var_1459,
)?;
object_1460.finish();
}
if let Some(var_1461) = &input.static_values {
let mut array_1462 = object.key("StaticValues").start_array();
for item_1463 in var_1461 {
{
array_1462.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*item_1463).into()),
);
}
}
array_1462.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_decimal_value_when_unset_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DecimalValueWhenUnsetConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1464) = &input.value_when_unset_option {
object.key("ValueWhenUnsetOption").string(var_1464.as_str());
}
if let Some(var_1465) = &input.custom_value {
object.key("CustomValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_1465).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_integer_default_values(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IntegerDefaultValues,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1466) = &input.dynamic_value {
#[allow(unused_mut)]
let mut object_1467 = object.key("DynamicValue").start_object();
crate::json_ser::serialize_structure_crate_model_dynamic_default_value(
&mut object_1467,
var_1466,
)?;
object_1467.finish();
}
if let Some(var_1468) = &input.static_values {
let mut array_1469 = object.key("StaticValues").start_array();
for item_1470 in var_1468 {
{
array_1469.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*item_1470).into()),
);
}
}
array_1469.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_integer_value_when_unset_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IntegerValueWhenUnsetConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1471) = &input.value_when_unset_option {
object.key("ValueWhenUnsetOption").string(var_1471.as_str());
}
if let Some(var_1472) = &input.custom_value {
object.key("CustomValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1472).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_date_time_default_values(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DateTimeDefaultValues,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1473) = &input.dynamic_value {
#[allow(unused_mut)]
let mut object_1474 = object.key("DynamicValue").start_object();
crate::json_ser::serialize_structure_crate_model_dynamic_default_value(
&mut object_1474,
var_1473,
)?;
object_1474.finish();
}
if let Some(var_1475) = &input.static_values {
let mut array_1476 = object.key("StaticValues").start_array();
for item_1477 in var_1475 {
{
array_1476
.value()
.date_time(item_1477, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
}
array_1476.finish();
}
if let Some(var_1478) = &input.rolling_date {
#[allow(unused_mut)]
let mut object_1479 = object.key("RollingDate").start_object();
crate::json_ser::serialize_structure_crate_model_rolling_date_configuration(
&mut object_1479,
var_1478,
)?;
object_1479.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_date_time_value_when_unset_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DateTimeValueWhenUnsetConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1480) = &input.value_when_unset_option {
object.key("ValueWhenUnsetOption").string(var_1480.as_str());
}
if let Some(var_1481) = &input.custom_value {
object
.key("CustomValue")
.date_time(var_1481, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_category_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CategoryFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1482) = &input.filter_id {
object.key("FilterId").string(var_1482.as_str());
}
if let Some(var_1483) = &input.column {
#[allow(unused_mut)]
let mut object_1484 = object.key("Column").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_1484,
var_1483,
)?;
object_1484.finish();
}
if let Some(var_1485) = &input.configuration {
#[allow(unused_mut)]
let mut object_1486 = object.key("Configuration").start_object();
crate::json_ser::serialize_structure_crate_model_category_filter_configuration(
&mut object_1486,
var_1485,
)?;
object_1486.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_numeric_range_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NumericRangeFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1487) = &input.filter_id {
object.key("FilterId").string(var_1487.as_str());
}
if let Some(var_1488) = &input.column {
#[allow(unused_mut)]
let mut object_1489 = object.key("Column").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_1489,
var_1488,
)?;
object_1489.finish();
}
if let Some(var_1490) = &input.include_minimum {
object.key("IncludeMinimum").boolean(*var_1490);
}
if let Some(var_1491) = &input.include_maximum {
object.key("IncludeMaximum").boolean(*var_1491);
}
if let Some(var_1492) = &input.range_minimum {
#[allow(unused_mut)]
let mut object_1493 = object.key("RangeMinimum").start_object();
crate::json_ser::serialize_structure_crate_model_numeric_range_filter_value(
&mut object_1493,
var_1492,
)?;
object_1493.finish();
}
if let Some(var_1494) = &input.range_maximum {
#[allow(unused_mut)]
let mut object_1495 = object.key("RangeMaximum").start_object();
crate::json_ser::serialize_structure_crate_model_numeric_range_filter_value(
&mut object_1495,
var_1494,
)?;
object_1495.finish();
}
if let Some(var_1496) = &input.select_all_options {
object.key("SelectAllOptions").string(var_1496.as_str());
}
if let Some(var_1497) = &input.aggregation_function {
#[allow(unused_mut)]
let mut object_1498 = object.key("AggregationFunction").start_object();
crate::json_ser::serialize_structure_crate_model_aggregation_function(
&mut object_1498,
var_1497,
)?;
object_1498.finish();
}
if let Some(var_1499) = &input.null_option {
object.key("NullOption").string(var_1499.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_numeric_equality_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NumericEqualityFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1500) = &input.filter_id {
object.key("FilterId").string(var_1500.as_str());
}
if let Some(var_1501) = &input.column {
#[allow(unused_mut)]
let mut object_1502 = object.key("Column").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_1502,
var_1501,
)?;
object_1502.finish();
}
if let Some(var_1503) = &input.value {
object.key("Value").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_1503).into()),
);
}
if let Some(var_1504) = &input.select_all_options {
object.key("SelectAllOptions").string(var_1504.as_str());
}
if let Some(var_1505) = &input.match_operator {
object.key("MatchOperator").string(var_1505.as_str());
}
if let Some(var_1506) = &input.aggregation_function {
#[allow(unused_mut)]
let mut object_1507 = object.key("AggregationFunction").start_object();
crate::json_ser::serialize_structure_crate_model_aggregation_function(
&mut object_1507,
var_1506,
)?;
object_1507.finish();
}
if let Some(var_1508) = &input.parameter_name {
object.key("ParameterName").string(var_1508.as_str());
}
if let Some(var_1509) = &input.null_option {
object.key("NullOption").string(var_1509.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_time_equality_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimeEqualityFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1510) = &input.filter_id {
object.key("FilterId").string(var_1510.as_str());
}
if let Some(var_1511) = &input.column {
#[allow(unused_mut)]
let mut object_1512 = object.key("Column").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_1512,
var_1511,
)?;
object_1512.finish();
}
if let Some(var_1513) = &input.value {
object
.key("Value")
.date_time(var_1513, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1514) = &input.parameter_name {
object.key("ParameterName").string(var_1514.as_str());
}
if let Some(var_1515) = &input.time_granularity {
object.key("TimeGranularity").string(var_1515.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_time_range_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimeRangeFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1516) = &input.filter_id {
object.key("FilterId").string(var_1516.as_str());
}
if let Some(var_1517) = &input.column {
#[allow(unused_mut)]
let mut object_1518 = object.key("Column").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_1518,
var_1517,
)?;
object_1518.finish();
}
if let Some(var_1519) = &input.include_minimum {
object.key("IncludeMinimum").boolean(*var_1519);
}
if let Some(var_1520) = &input.include_maximum {
object.key("IncludeMaximum").boolean(*var_1520);
}
if let Some(var_1521) = &input.range_minimum_value {
#[allow(unused_mut)]
let mut object_1522 = object.key("RangeMinimumValue").start_object();
crate::json_ser::serialize_structure_crate_model_time_range_filter_value(
&mut object_1522,
var_1521,
)?;
object_1522.finish();
}
if let Some(var_1523) = &input.range_maximum_value {
#[allow(unused_mut)]
let mut object_1524 = object.key("RangeMaximumValue").start_object();
crate::json_ser::serialize_structure_crate_model_time_range_filter_value(
&mut object_1524,
var_1523,
)?;
object_1524.finish();
}
if let Some(var_1525) = &input.null_option {
object.key("NullOption").string(var_1525.as_str());
}
if let Some(var_1526) = &input.exclude_period_configuration {
#[allow(unused_mut)]
let mut object_1527 = object.key("ExcludePeriodConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_exclude_period_configuration(
&mut object_1527,
var_1526,
)?;
object_1527.finish();
}
if let Some(var_1528) = &input.time_granularity {
object.key("TimeGranularity").string(var_1528.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_relative_dates_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RelativeDatesFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1529) = &input.filter_id {
object.key("FilterId").string(var_1529.as_str());
}
if let Some(var_1530) = &input.column {
#[allow(unused_mut)]
let mut object_1531 = object.key("Column").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_1531,
var_1530,
)?;
object_1531.finish();
}
if let Some(var_1532) = &input.anchor_date_configuration {
#[allow(unused_mut)]
let mut object_1533 = object.key("AnchorDateConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_anchor_date_configuration(
&mut object_1533,
var_1532,
)?;
object_1533.finish();
}
if let Some(var_1534) = &input.minimum_granularity {
object.key("MinimumGranularity").string(var_1534.as_str());
}
if let Some(var_1535) = &input.time_granularity {
object.key("TimeGranularity").string(var_1535.as_str());
}
if let Some(var_1536) = &input.relative_date_type {
object.key("RelativeDateType").string(var_1536.as_str());
}
if let Some(var_1537) = &input.relative_date_value {
object.key("RelativeDateValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1537).into()),
);
}
if let Some(var_1538) = &input.parameter_name {
object.key("ParameterName").string(var_1538.as_str());
}
if let Some(var_1539) = &input.null_option {
object.key("NullOption").string(var_1539.as_str());
}
if let Some(var_1540) = &input.exclude_period_configuration {
#[allow(unused_mut)]
let mut object_1541 = object.key("ExcludePeriodConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_exclude_period_configuration(
&mut object_1541,
var_1540,
)?;
object_1541.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_top_bottom_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TopBottomFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1542) = &input.filter_id {
object.key("FilterId").string(var_1542.as_str());
}
if let Some(var_1543) = &input.column {
#[allow(unused_mut)]
let mut object_1544 = object.key("Column").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_1544,
var_1543,
)?;
object_1544.finish();
}
if let Some(var_1545) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1545).into()),
);
}
if let Some(var_1546) = &input.aggregation_sort_configurations {
let mut array_1547 = object.key("AggregationSortConfigurations").start_array();
for item_1548 in var_1546 {
{
#[allow(unused_mut)]
let mut object_1549 = array_1547.value().start_object();
crate::json_ser::serialize_structure_crate_model_aggregation_sort_configuration(
&mut object_1549,
item_1548,
)?;
object_1549.finish();
}
}
array_1547.finish();
}
if let Some(var_1550) = &input.time_granularity {
object.key("TimeGranularity").string(var_1550.as_str());
}
if let Some(var_1551) = &input.parameter_name {
object.key("ParameterName").string(var_1551.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_selected_sheets_filter_scope_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SelectedSheetsFilterScopeConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1552) = &input.sheet_visual_scoping_configurations {
let mut array_1553 = object.key("SheetVisualScopingConfigurations").start_array();
for item_1554 in var_1552 {
{
#[allow(unused_mut)]
let mut object_1555 = array_1553.value().start_object();
crate::json_ser::serialize_structure_crate_model_sheet_visual_scoping_configuration(&mut object_1555, item_1554)?;
object_1555.finish();
}
}
array_1553.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_string_format_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StringFormatConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1556) = &input.null_value_format_configuration {
#[allow(unused_mut)]
let mut object_1557 = object.key("NullValueFormatConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_null_value_format_configuration(
&mut object_1557,
var_1556,
)?;
object_1557.finish();
}
if let Some(var_1558) = &input.numeric_format_configuration {
#[allow(unused_mut)]
let mut object_1559 = object.key("NumericFormatConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_numeric_format_configuration(
&mut object_1559,
var_1558,
)?;
object_1559.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_number_format_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NumberFormatConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1560) = &input.format_configuration {
#[allow(unused_mut)]
let mut object_1561 = object.key("FormatConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_numeric_format_configuration(
&mut object_1561,
var_1560,
)?;
object_1561.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_date_time_format_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DateTimeFormatConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1562) = &input.date_time_format {
object.key("DateTimeFormat").string(var_1562.as_str());
}
if let Some(var_1563) = &input.null_value_format_configuration {
#[allow(unused_mut)]
let mut object_1564 = object.key("NullValueFormatConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_null_value_format_configuration(
&mut object_1564,
var_1563,
)?;
object_1564.finish();
}
if let Some(var_1565) = &input.numeric_format_configuration {
#[allow(unused_mut)]
let mut object_1566 = object.key("NumericFormatConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_numeric_format_configuration(
&mut object_1566,
var_1565,
)?;
object_1566.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_default_interactive_layout_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DefaultInteractiveLayoutConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1567) = &input.grid {
#[allow(unused_mut)]
let mut object_1568 = object.key("Grid").start_object();
crate::json_ser::serialize_structure_crate_model_default_grid_layout_configuration(
&mut object_1568,
var_1567,
)?;
object_1568.finish();
}
if let Some(var_1569) = &input.free_form {
#[allow(unused_mut)]
let mut object_1570 = object.key("FreeForm").start_object();
crate::json_ser::serialize_structure_crate_model_default_free_form_layout_configuration(
&mut object_1570,
var_1569,
)?;
object_1570.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_default_paginated_layout_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DefaultPaginatedLayoutConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1571) = &input.section_based {
#[allow(unused_mut)]
let mut object_1572 = object.key("SectionBased").start_object();
crate::json_ser::serialize_structure_crate_model_default_section_based_layout_configuration(&mut object_1572, var_1571)?;
object_1572.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_calculated_column(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CalculatedColumn,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1573) = &input.column_name {
object.key("ColumnName").string(var_1573.as_str());
}
if let Some(var_1574) = &input.column_id {
object.key("ColumnId").string(var_1574.as_str());
}
if let Some(var_1575) = &input.expression {
object.key("Expression").string(var_1575.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_column_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ColumnTag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1576) = &input.column_geographic_role {
object.key("ColumnGeographicRole").string(var_1576.as_str());
}
if let Some(var_1577) = &input.column_description {
#[allow(unused_mut)]
let mut object_1578 = object.key("ColumnDescription").start_object();
crate::json_ser::serialize_structure_crate_model_column_description(
&mut object_1578,
var_1577,
)?;
object_1578.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_join_key_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JoinKeyProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1579) = &input.unique_key {
object.key("UniqueKey").boolean(*var_1579);
}
Ok(())
}
pub fn serialize_structure_crate_model_column_schema(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ColumnSchema,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1580) = &input.name {
object.key("Name").string(var_1580.as_str());
}
if let Some(var_1581) = &input.data_type {
object.key("DataType").string(var_1581.as_str());
}
if let Some(var_1582) = &input.geographic_role {
object.key("GeographicRole").string(var_1582.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_column_group_column_schema(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ColumnGroupColumnSchema,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1583) = &input.name {
object.key("Name").string(var_1583.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_border_style(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BorderStyle,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1584) = &input.show {
object.key("Show").boolean(*var_1584);
}
Ok(())
}
pub fn serialize_structure_crate_model_gutter_style(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GutterStyle,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1585) = &input.show {
object.key("Show").boolean(*var_1585);
}
Ok(())
}
pub fn serialize_structure_crate_model_margin_style(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MarginStyle,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1586) = &input.show {
object.key("Show").boolean(*var_1586);
}
Ok(())
}
pub fn serialize_structure_crate_model_date_time_picker_control_display_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DateTimePickerControlDisplayOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1587) = &input.title_options {
#[allow(unused_mut)]
let mut object_1588 = object.key("TitleOptions").start_object();
crate::json_ser::serialize_structure_crate_model_label_options(&mut object_1588, var_1587)?;
object_1588.finish();
}
if let Some(var_1589) = &input.date_time_format {
object.key("DateTimeFormat").string(var_1589.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_list_control_display_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListControlDisplayOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1590) = &input.search_options {
#[allow(unused_mut)]
let mut object_1591 = object.key("SearchOptions").start_object();
crate::json_ser::serialize_structure_crate_model_list_control_search_options(
&mut object_1591,
var_1590,
)?;
object_1591.finish();
}
if let Some(var_1592) = &input.select_all_options {
#[allow(unused_mut)]
let mut object_1593 = object.key("SelectAllOptions").start_object();
crate::json_ser::serialize_structure_crate_model_list_control_select_all_options(
&mut object_1593,
var_1592,
)?;
object_1593.finish();
}
if let Some(var_1594) = &input.title_options {
#[allow(unused_mut)]
let mut object_1595 = object.key("TitleOptions").start_object();
crate::json_ser::serialize_structure_crate_model_label_options(&mut object_1595, var_1594)?;
object_1595.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_parameter_selectable_values(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParameterSelectableValues,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1596) = &input.values {
let mut array_1597 = object.key("Values").start_array();
for item_1598 in var_1596 {
{
array_1597.value().string(item_1598.as_str());
}
}
array_1597.finish();
}
if let Some(var_1599) = &input.link_to_data_set_column {
#[allow(unused_mut)]
let mut object_1600 = object.key("LinkToDataSetColumn").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_1600,
var_1599,
)?;
object_1600.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_cascading_control_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CascadingControlConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1601) = &input.source_controls {
let mut array_1602 = object.key("SourceControls").start_array();
for item_1603 in var_1601 {
{
#[allow(unused_mut)]
let mut object_1604 = array_1602.value().start_object();
crate::json_ser::serialize_structure_crate_model_cascading_control_source(
&mut object_1604,
item_1603,
)?;
object_1604.finish();
}
}
array_1602.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_drop_down_control_display_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DropDownControlDisplayOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1605) = &input.select_all_options {
#[allow(unused_mut)]
let mut object_1606 = object.key("SelectAllOptions").start_object();
crate::json_ser::serialize_structure_crate_model_list_control_select_all_options(
&mut object_1606,
var_1605,
)?;
object_1606.finish();
}
if let Some(var_1607) = &input.title_options {
#[allow(unused_mut)]
let mut object_1608 = object.key("TitleOptions").start_object();
crate::json_ser::serialize_structure_crate_model_label_options(&mut object_1608, var_1607)?;
object_1608.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_text_field_control_display_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TextFieldControlDisplayOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1609) = &input.title_options {
#[allow(unused_mut)]
let mut object_1610 = object.key("TitleOptions").start_object();
crate::json_ser::serialize_structure_crate_model_label_options(&mut object_1610, var_1609)?;
object_1610.finish();
}
if let Some(var_1611) = &input.placeholder_options {
#[allow(unused_mut)]
let mut object_1612 = object.key("PlaceholderOptions").start_object();
crate::json_ser::serialize_structure_crate_model_text_control_placeholder_options(
&mut object_1612,
var_1611,
)?;
object_1612.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_text_area_control_display_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TextAreaControlDisplayOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1613) = &input.title_options {
#[allow(unused_mut)]
let mut object_1614 = object.key("TitleOptions").start_object();
crate::json_ser::serialize_structure_crate_model_label_options(&mut object_1614, var_1613)?;
object_1614.finish();
}
if let Some(var_1615) = &input.placeholder_options {
#[allow(unused_mut)]
let mut object_1616 = object.key("PlaceholderOptions").start_object();
crate::json_ser::serialize_structure_crate_model_text_control_placeholder_options(
&mut object_1616,
var_1615,
)?;
object_1616.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_slider_control_display_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SliderControlDisplayOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1617) = &input.title_options {
#[allow(unused_mut)]
let mut object_1618 = object.key("TitleOptions").start_object();
crate::json_ser::serialize_structure_crate_model_label_options(&mut object_1618, var_1617)?;
object_1618.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_selectable_values(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterSelectableValues,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1619) = &input.values {
let mut array_1620 = object.key("Values").start_array();
for item_1621 in var_1619 {
{
array_1620.value().string(item_1621.as_str());
}
}
array_1620.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_relative_date_time_control_display_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RelativeDateTimeControlDisplayOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1622) = &input.title_options {
#[allow(unused_mut)]
let mut object_1623 = object.key("TitleOptions").start_object();
crate::json_ser::serialize_structure_crate_model_label_options(&mut object_1623, var_1622)?;
object_1623.finish();
}
if let Some(var_1624) = &input.date_time_format {
object.key("DateTimeFormat").string(var_1624.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_visual_title_label_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VisualTitleLabelOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1625) = &input.visibility {
object.key("Visibility").string(var_1625.as_str());
}
if let Some(var_1626) = &input.format_text {
#[allow(unused_mut)]
let mut object_1627 = object.key("FormatText").start_object();
crate::json_ser::serialize_structure_crate_model_short_format_text(
&mut object_1627,
var_1626,
)?;
object_1627.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_visual_subtitle_label_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VisualSubtitleLabelOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1628) = &input.visibility {
object.key("Visibility").string(var_1628.as_str());
}
if let Some(var_1629) = &input.format_text {
#[allow(unused_mut)]
let mut object_1630 = object.key("FormatText").start_object();
crate::json_ser::serialize_structure_crate_model_long_format_text(
&mut object_1630,
var_1629,
)?;
object_1630.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_table_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1631) = &input.field_wells {
#[allow(unused_mut)]
let mut object_1632 = object.key("FieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_table_field_wells(
&mut object_1632,
var_1631,
)?;
object_1632.finish();
}
if let Some(var_1633) = &input.sort_configuration {
#[allow(unused_mut)]
let mut object_1634 = object.key("SortConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_table_sort_configuration(
&mut object_1634,
var_1633,
)?;
object_1634.finish();
}
if let Some(var_1635) = &input.table_options {
#[allow(unused_mut)]
let mut object_1636 = object.key("TableOptions").start_object();
crate::json_ser::serialize_structure_crate_model_table_options(&mut object_1636, var_1635)?;
object_1636.finish();
}
if let Some(var_1637) = &input.total_options {
#[allow(unused_mut)]
let mut object_1638 = object.key("TotalOptions").start_object();
crate::json_ser::serialize_structure_crate_model_total_options(&mut object_1638, var_1637)?;
object_1638.finish();
}
if let Some(var_1639) = &input.field_options {
#[allow(unused_mut)]
let mut object_1640 = object.key("FieldOptions").start_object();
crate::json_ser::serialize_structure_crate_model_table_field_options(
&mut object_1640,
var_1639,
)?;
object_1640.finish();
}
if let Some(var_1641) = &input.paginated_report_options {
#[allow(unused_mut)]
let mut object_1642 = object.key("PaginatedReportOptions").start_object();
crate::json_ser::serialize_structure_crate_model_table_paginated_report_options(
&mut object_1642,
var_1641,
)?;
object_1642.finish();
}
if let Some(var_1643) = &input.table_inline_visualizations {
let mut array_1644 = object.key("TableInlineVisualizations").start_array();
for item_1645 in var_1643 {
{
#[allow(unused_mut)]
let mut object_1646 = array_1644.value().start_object();
crate::json_ser::serialize_structure_crate_model_table_inline_visualization(
&mut object_1646,
item_1645,
)?;
object_1646.finish();
}
}
array_1644.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_table_conditional_formatting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableConditionalFormatting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1647) = &input.conditional_formatting_options {
let mut array_1648 = object.key("ConditionalFormattingOptions").start_array();
for item_1649 in var_1647 {
{
#[allow(unused_mut)]
let mut object_1650 = array_1648.value().start_object();
crate::json_ser::serialize_structure_crate_model_table_conditional_formatting_option(&mut object_1650, item_1649)?;
object_1650.finish();
}
}
array_1648.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_visual_custom_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VisualCustomAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1651) = &input.custom_action_id {
object.key("CustomActionId").string(var_1651.as_str());
}
if let Some(var_1652) = &input.name {
object.key("Name").string(var_1652.as_str());
}
if let Some(var_1653) = &input.status {
object.key("Status").string(var_1653.as_str());
}
if let Some(var_1654) = &input.trigger {
object.key("Trigger").string(var_1654.as_str());
}
if let Some(var_1655) = &input.action_operations {
let mut array_1656 = object.key("ActionOperations").start_array();
for item_1657 in var_1655 {
{
#[allow(unused_mut)]
let mut object_1658 = array_1656.value().start_object();
crate::json_ser::serialize_structure_crate_model_visual_custom_action_operation(
&mut object_1658,
item_1657,
)?;
object_1658.finish();
}
}
array_1656.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pivot_table_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PivotTableConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1659) = &input.field_wells {
#[allow(unused_mut)]
let mut object_1660 = object.key("FieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_pivot_table_field_wells(
&mut object_1660,
var_1659,
)?;
object_1660.finish();
}
if let Some(var_1661) = &input.sort_configuration {
#[allow(unused_mut)]
let mut object_1662 = object.key("SortConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_pivot_table_sort_configuration(
&mut object_1662,
var_1661,
)?;
object_1662.finish();
}
if let Some(var_1663) = &input.table_options {
#[allow(unused_mut)]
let mut object_1664 = object.key("TableOptions").start_object();
crate::json_ser::serialize_structure_crate_model_pivot_table_options(
&mut object_1664,
var_1663,
)?;
object_1664.finish();
}
if let Some(var_1665) = &input.total_options {
#[allow(unused_mut)]
let mut object_1666 = object.key("TotalOptions").start_object();
crate::json_ser::serialize_structure_crate_model_pivot_table_total_options(
&mut object_1666,
var_1665,
)?;
object_1666.finish();
}
if let Some(var_1667) = &input.field_options {
#[allow(unused_mut)]
let mut object_1668 = object.key("FieldOptions").start_object();
crate::json_ser::serialize_structure_crate_model_pivot_table_field_options(
&mut object_1668,
var_1667,
)?;
object_1668.finish();
}
if let Some(var_1669) = &input.paginated_report_options {
#[allow(unused_mut)]
let mut object_1670 = object.key("PaginatedReportOptions").start_object();
crate::json_ser::serialize_structure_crate_model_pivot_table_paginated_report_options(
&mut object_1670,
var_1669,
)?;
object_1670.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pivot_table_conditional_formatting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PivotTableConditionalFormatting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1671) = &input.conditional_formatting_options {
let mut array_1672 = object.key("ConditionalFormattingOptions").start_array();
for item_1673 in var_1671 {
{
#[allow(unused_mut)]
let mut object_1674 = array_1672.value().start_object();
crate::json_ser::serialize_structure_crate_model_pivot_table_conditional_formatting_option(&mut object_1674, item_1673)?;
object_1674.finish();
}
}
array_1672.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_bar_chart_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BarChartConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1675) = &input.field_wells {
#[allow(unused_mut)]
let mut object_1676 = object.key("FieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_bar_chart_field_wells(
&mut object_1676,
var_1675,
)?;
object_1676.finish();
}
if let Some(var_1677) = &input.sort_configuration {
#[allow(unused_mut)]
let mut object_1678 = object.key("SortConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_bar_chart_sort_configuration(
&mut object_1678,
var_1677,
)?;
object_1678.finish();
}
if let Some(var_1679) = &input.orientation {
object.key("Orientation").string(var_1679.as_str());
}
if let Some(var_1680) = &input.bars_arrangement {
object.key("BarsArrangement").string(var_1680.as_str());
}
if let Some(var_1681) = &input.visual_palette {
#[allow(unused_mut)]
let mut object_1682 = object.key("VisualPalette").start_object();
crate::json_ser::serialize_structure_crate_model_visual_palette(
&mut object_1682,
var_1681,
)?;
object_1682.finish();
}
if let Some(var_1683) = &input.small_multiples_options {
#[allow(unused_mut)]
let mut object_1684 = object.key("SmallMultiplesOptions").start_object();
crate::json_ser::serialize_structure_crate_model_small_multiples_options(
&mut object_1684,
var_1683,
)?;
object_1684.finish();
}
if let Some(var_1685) = &input.category_axis {
#[allow(unused_mut)]
let mut object_1686 = object.key("CategoryAxis").start_object();
crate::json_ser::serialize_structure_crate_model_axis_display_options(
&mut object_1686,
var_1685,
)?;
object_1686.finish();
}
if let Some(var_1687) = &input.category_label_options {
#[allow(unused_mut)]
let mut object_1688 = object.key("CategoryLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1688,
var_1687,
)?;
object_1688.finish();
}
if let Some(var_1689) = &input.value_axis {
#[allow(unused_mut)]
let mut object_1690 = object.key("ValueAxis").start_object();
crate::json_ser::serialize_structure_crate_model_axis_display_options(
&mut object_1690,
var_1689,
)?;
object_1690.finish();
}
if let Some(var_1691) = &input.value_label_options {
#[allow(unused_mut)]
let mut object_1692 = object.key("ValueLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1692,
var_1691,
)?;
object_1692.finish();
}
if let Some(var_1693) = &input.color_label_options {
#[allow(unused_mut)]
let mut object_1694 = object.key("ColorLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1694,
var_1693,
)?;
object_1694.finish();
}
if let Some(var_1695) = &input.legend {
#[allow(unused_mut)]
let mut object_1696 = object.key("Legend").start_object();
crate::json_ser::serialize_structure_crate_model_legend_options(
&mut object_1696,
var_1695,
)?;
object_1696.finish();
}
if let Some(var_1697) = &input.data_labels {
#[allow(unused_mut)]
let mut object_1698 = object.key("DataLabels").start_object();
crate::json_ser::serialize_structure_crate_model_data_label_options(
&mut object_1698,
var_1697,
)?;
object_1698.finish();
}
if let Some(var_1699) = &input.tooltip {
#[allow(unused_mut)]
let mut object_1700 = object.key("Tooltip").start_object();
crate::json_ser::serialize_structure_crate_model_tooltip_options(
&mut object_1700,
var_1699,
)?;
object_1700.finish();
}
if let Some(var_1701) = &input.reference_lines {
let mut array_1702 = object.key("ReferenceLines").start_array();
for item_1703 in var_1701 {
{
#[allow(unused_mut)]
let mut object_1704 = array_1702.value().start_object();
crate::json_ser::serialize_structure_crate_model_reference_line(
&mut object_1704,
item_1703,
)?;
object_1704.finish();
}
}
array_1702.finish();
}
if let Some(var_1705) = &input.contribution_analysis_defaults {
let mut array_1706 = object.key("ContributionAnalysisDefaults").start_array();
for item_1707 in var_1705 {
{
#[allow(unused_mut)]
let mut object_1708 = array_1706.value().start_object();
crate::json_ser::serialize_structure_crate_model_contribution_analysis_default(
&mut object_1708,
item_1707,
)?;
object_1708.finish();
}
}
array_1706.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_column_hierarchy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ColumnHierarchy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1709) = &input.explicit_hierarchy {
#[allow(unused_mut)]
let mut object_1710 = object.key("ExplicitHierarchy").start_object();
crate::json_ser::serialize_structure_crate_model_explicit_hierarchy(
&mut object_1710,
var_1709,
)?;
object_1710.finish();
}
if let Some(var_1711) = &input.date_time_hierarchy {
#[allow(unused_mut)]
let mut object_1712 = object.key("DateTimeHierarchy").start_object();
crate::json_ser::serialize_structure_crate_model_date_time_hierarchy(
&mut object_1712,
var_1711,
)?;
object_1712.finish();
}
if let Some(var_1713) = &input.predefined_hierarchy {
#[allow(unused_mut)]
let mut object_1714 = object.key("PredefinedHierarchy").start_object();
crate::json_ser::serialize_structure_crate_model_predefined_hierarchy(
&mut object_1714,
var_1713,
)?;
object_1714.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_kpi_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KpiConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1715) = &input.field_wells {
#[allow(unused_mut)]
let mut object_1716 = object.key("FieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_kpi_field_wells(
&mut object_1716,
var_1715,
)?;
object_1716.finish();
}
if let Some(var_1717) = &input.sort_configuration {
#[allow(unused_mut)]
let mut object_1718 = object.key("SortConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_kpi_sort_configuration(
&mut object_1718,
var_1717,
)?;
object_1718.finish();
}
if let Some(var_1719) = &input.kpi_options {
#[allow(unused_mut)]
let mut object_1720 = object.key("KPIOptions").start_object();
crate::json_ser::serialize_structure_crate_model_kpi_options(&mut object_1720, var_1719)?;
object_1720.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_kpi_conditional_formatting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KpiConditionalFormatting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1721) = &input.conditional_formatting_options {
let mut array_1722 = object.key("ConditionalFormattingOptions").start_array();
for item_1723 in var_1721 {
{
#[allow(unused_mut)]
let mut object_1724 = array_1722.value().start_object();
crate::json_ser::serialize_structure_crate_model_kpi_conditional_formatting_option(
&mut object_1724,
item_1723,
)?;
object_1724.finish();
}
}
array_1722.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pie_chart_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PieChartConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1725) = &input.field_wells {
#[allow(unused_mut)]
let mut object_1726 = object.key("FieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_pie_chart_field_wells(
&mut object_1726,
var_1725,
)?;
object_1726.finish();
}
if let Some(var_1727) = &input.sort_configuration {
#[allow(unused_mut)]
let mut object_1728 = object.key("SortConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_pie_chart_sort_configuration(
&mut object_1728,
var_1727,
)?;
object_1728.finish();
}
if let Some(var_1729) = &input.donut_options {
#[allow(unused_mut)]
let mut object_1730 = object.key("DonutOptions").start_object();
crate::json_ser::serialize_structure_crate_model_donut_options(&mut object_1730, var_1729)?;
object_1730.finish();
}
if let Some(var_1731) = &input.small_multiples_options {
#[allow(unused_mut)]
let mut object_1732 = object.key("SmallMultiplesOptions").start_object();
crate::json_ser::serialize_structure_crate_model_small_multiples_options(
&mut object_1732,
var_1731,
)?;
object_1732.finish();
}
if let Some(var_1733) = &input.category_label_options {
#[allow(unused_mut)]
let mut object_1734 = object.key("CategoryLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1734,
var_1733,
)?;
object_1734.finish();
}
if let Some(var_1735) = &input.value_label_options {
#[allow(unused_mut)]
let mut object_1736 = object.key("ValueLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1736,
var_1735,
)?;
object_1736.finish();
}
if let Some(var_1737) = &input.legend {
#[allow(unused_mut)]
let mut object_1738 = object.key("Legend").start_object();
crate::json_ser::serialize_structure_crate_model_legend_options(
&mut object_1738,
var_1737,
)?;
object_1738.finish();
}
if let Some(var_1739) = &input.data_labels {
#[allow(unused_mut)]
let mut object_1740 = object.key("DataLabels").start_object();
crate::json_ser::serialize_structure_crate_model_data_label_options(
&mut object_1740,
var_1739,
)?;
object_1740.finish();
}
if let Some(var_1741) = &input.tooltip {
#[allow(unused_mut)]
let mut object_1742 = object.key("Tooltip").start_object();
crate::json_ser::serialize_structure_crate_model_tooltip_options(
&mut object_1742,
var_1741,
)?;
object_1742.finish();
}
if let Some(var_1743) = &input.visual_palette {
#[allow(unused_mut)]
let mut object_1744 = object.key("VisualPalette").start_object();
crate::json_ser::serialize_structure_crate_model_visual_palette(
&mut object_1744,
var_1743,
)?;
object_1744.finish();
}
if let Some(var_1745) = &input.contribution_analysis_defaults {
let mut array_1746 = object.key("ContributionAnalysisDefaults").start_array();
for item_1747 in var_1745 {
{
#[allow(unused_mut)]
let mut object_1748 = array_1746.value().start_object();
crate::json_ser::serialize_structure_crate_model_contribution_analysis_default(
&mut object_1748,
item_1747,
)?;
object_1748.finish();
}
}
array_1746.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_gauge_chart_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GaugeChartConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1749) = &input.field_wells {
#[allow(unused_mut)]
let mut object_1750 = object.key("FieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_gauge_chart_field_wells(
&mut object_1750,
var_1749,
)?;
object_1750.finish();
}
if let Some(var_1751) = &input.gauge_chart_options {
#[allow(unused_mut)]
let mut object_1752 = object.key("GaugeChartOptions").start_object();
crate::json_ser::serialize_structure_crate_model_gauge_chart_options(
&mut object_1752,
var_1751,
)?;
object_1752.finish();
}
if let Some(var_1753) = &input.data_labels {
#[allow(unused_mut)]
let mut object_1754 = object.key("DataLabels").start_object();
crate::json_ser::serialize_structure_crate_model_data_label_options(
&mut object_1754,
var_1753,
)?;
object_1754.finish();
}
if let Some(var_1755) = &input.tooltip_options {
#[allow(unused_mut)]
let mut object_1756 = object.key("TooltipOptions").start_object();
crate::json_ser::serialize_structure_crate_model_tooltip_options(
&mut object_1756,
var_1755,
)?;
object_1756.finish();
}
if let Some(var_1757) = &input.visual_palette {
#[allow(unused_mut)]
let mut object_1758 = object.key("VisualPalette").start_object();
crate::json_ser::serialize_structure_crate_model_visual_palette(
&mut object_1758,
var_1757,
)?;
object_1758.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_gauge_chart_conditional_formatting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GaugeChartConditionalFormatting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1759) = &input.conditional_formatting_options {
let mut array_1760 = object.key("ConditionalFormattingOptions").start_array();
for item_1761 in var_1759 {
{
#[allow(unused_mut)]
let mut object_1762 = array_1760.value().start_object();
crate::json_ser::serialize_structure_crate_model_gauge_chart_conditional_formatting_option(&mut object_1762, item_1761)?;
object_1762.finish();
}
}
array_1760.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_line_chart_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LineChartConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1763) = &input.field_wells {
#[allow(unused_mut)]
let mut object_1764 = object.key("FieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_line_chart_field_wells(
&mut object_1764,
var_1763,
)?;
object_1764.finish();
}
if let Some(var_1765) = &input.sort_configuration {
#[allow(unused_mut)]
let mut object_1766 = object.key("SortConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_line_chart_sort_configuration(
&mut object_1766,
var_1765,
)?;
object_1766.finish();
}
if let Some(var_1767) = &input.forecast_configurations {
let mut array_1768 = object.key("ForecastConfigurations").start_array();
for item_1769 in var_1767 {
{
#[allow(unused_mut)]
let mut object_1770 = array_1768.value().start_object();
crate::json_ser::serialize_structure_crate_model_forecast_configuration(
&mut object_1770,
item_1769,
)?;
object_1770.finish();
}
}
array_1768.finish();
}
if let Some(var_1771) = &input.r#type {
object.key("Type").string(var_1771.as_str());
}
if let Some(var_1772) = &input.small_multiples_options {
#[allow(unused_mut)]
let mut object_1773 = object.key("SmallMultiplesOptions").start_object();
crate::json_ser::serialize_structure_crate_model_small_multiples_options(
&mut object_1773,
var_1772,
)?;
object_1773.finish();
}
if let Some(var_1774) = &input.x_axis_display_options {
#[allow(unused_mut)]
let mut object_1775 = object.key("XAxisDisplayOptions").start_object();
crate::json_ser::serialize_structure_crate_model_axis_display_options(
&mut object_1775,
var_1774,
)?;
object_1775.finish();
}
if let Some(var_1776) = &input.x_axis_label_options {
#[allow(unused_mut)]
let mut object_1777 = object.key("XAxisLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1777,
var_1776,
)?;
object_1777.finish();
}
if let Some(var_1778) = &input.primary_y_axis_display_options {
#[allow(unused_mut)]
let mut object_1779 = object.key("PrimaryYAxisDisplayOptions").start_object();
crate::json_ser::serialize_structure_crate_model_line_series_axis_display_options(
&mut object_1779,
var_1778,
)?;
object_1779.finish();
}
if let Some(var_1780) = &input.primary_y_axis_label_options {
#[allow(unused_mut)]
let mut object_1781 = object.key("PrimaryYAxisLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1781,
var_1780,
)?;
object_1781.finish();
}
if let Some(var_1782) = &input.secondary_y_axis_display_options {
#[allow(unused_mut)]
let mut object_1783 = object.key("SecondaryYAxisDisplayOptions").start_object();
crate::json_ser::serialize_structure_crate_model_line_series_axis_display_options(
&mut object_1783,
var_1782,
)?;
object_1783.finish();
}
if let Some(var_1784) = &input.secondary_y_axis_label_options {
#[allow(unused_mut)]
let mut object_1785 = object.key("SecondaryYAxisLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1785,
var_1784,
)?;
object_1785.finish();
}
if let Some(var_1786) = &input.default_series_settings {
#[allow(unused_mut)]
let mut object_1787 = object.key("DefaultSeriesSettings").start_object();
crate::json_ser::serialize_structure_crate_model_line_chart_default_series_settings(
&mut object_1787,
var_1786,
)?;
object_1787.finish();
}
if let Some(var_1788) = &input.series {
let mut array_1789 = object.key("Series").start_array();
for item_1790 in var_1788 {
{
#[allow(unused_mut)]
let mut object_1791 = array_1789.value().start_object();
crate::json_ser::serialize_structure_crate_model_series_item(
&mut object_1791,
item_1790,
)?;
object_1791.finish();
}
}
array_1789.finish();
}
if let Some(var_1792) = &input.legend {
#[allow(unused_mut)]
let mut object_1793 = object.key("Legend").start_object();
crate::json_ser::serialize_structure_crate_model_legend_options(
&mut object_1793,
var_1792,
)?;
object_1793.finish();
}
if let Some(var_1794) = &input.data_labels {
#[allow(unused_mut)]
let mut object_1795 = object.key("DataLabels").start_object();
crate::json_ser::serialize_structure_crate_model_data_label_options(
&mut object_1795,
var_1794,
)?;
object_1795.finish();
}
if let Some(var_1796) = &input.reference_lines {
let mut array_1797 = object.key("ReferenceLines").start_array();
for item_1798 in var_1796 {
{
#[allow(unused_mut)]
let mut object_1799 = array_1797.value().start_object();
crate::json_ser::serialize_structure_crate_model_reference_line(
&mut object_1799,
item_1798,
)?;
object_1799.finish();
}
}
array_1797.finish();
}
if let Some(var_1800) = &input.tooltip {
#[allow(unused_mut)]
let mut object_1801 = object.key("Tooltip").start_object();
crate::json_ser::serialize_structure_crate_model_tooltip_options(
&mut object_1801,
var_1800,
)?;
object_1801.finish();
}
if let Some(var_1802) = &input.contribution_analysis_defaults {
let mut array_1803 = object.key("ContributionAnalysisDefaults").start_array();
for item_1804 in var_1802 {
{
#[allow(unused_mut)]
let mut object_1805 = array_1803.value().start_object();
crate::json_ser::serialize_structure_crate_model_contribution_analysis_default(
&mut object_1805,
item_1804,
)?;
object_1805.finish();
}
}
array_1803.finish();
}
if let Some(var_1806) = &input.visual_palette {
#[allow(unused_mut)]
let mut object_1807 = object.key("VisualPalette").start_object();
crate::json_ser::serialize_structure_crate_model_visual_palette(
&mut object_1807,
var_1806,
)?;
object_1807.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_heat_map_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HeatMapConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1808) = &input.field_wells {
#[allow(unused_mut)]
let mut object_1809 = object.key("FieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_heat_map_field_wells(
&mut object_1809,
var_1808,
)?;
object_1809.finish();
}
if let Some(var_1810) = &input.sort_configuration {
#[allow(unused_mut)]
let mut object_1811 = object.key("SortConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_heat_map_sort_configuration(
&mut object_1811,
var_1810,
)?;
object_1811.finish();
}
if let Some(var_1812) = &input.row_label_options {
#[allow(unused_mut)]
let mut object_1813 = object.key("RowLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1813,
var_1812,
)?;
object_1813.finish();
}
if let Some(var_1814) = &input.column_label_options {
#[allow(unused_mut)]
let mut object_1815 = object.key("ColumnLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1815,
var_1814,
)?;
object_1815.finish();
}
if let Some(var_1816) = &input.color_scale {
#[allow(unused_mut)]
let mut object_1817 = object.key("ColorScale").start_object();
crate::json_ser::serialize_structure_crate_model_color_scale(&mut object_1817, var_1816)?;
object_1817.finish();
}
if let Some(var_1818) = &input.legend {
#[allow(unused_mut)]
let mut object_1819 = object.key("Legend").start_object();
crate::json_ser::serialize_structure_crate_model_legend_options(
&mut object_1819,
var_1818,
)?;
object_1819.finish();
}
if let Some(var_1820) = &input.data_labels {
#[allow(unused_mut)]
let mut object_1821 = object.key("DataLabels").start_object();
crate::json_ser::serialize_structure_crate_model_data_label_options(
&mut object_1821,
var_1820,
)?;
object_1821.finish();
}
if let Some(var_1822) = &input.tooltip {
#[allow(unused_mut)]
let mut object_1823 = object.key("Tooltip").start_object();
crate::json_ser::serialize_structure_crate_model_tooltip_options(
&mut object_1823,
var_1822,
)?;
object_1823.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tree_map_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TreeMapConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1824) = &input.field_wells {
#[allow(unused_mut)]
let mut object_1825 = object.key("FieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_tree_map_field_wells(
&mut object_1825,
var_1824,
)?;
object_1825.finish();
}
if let Some(var_1826) = &input.sort_configuration {
#[allow(unused_mut)]
let mut object_1827 = object.key("SortConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_tree_map_sort_configuration(
&mut object_1827,
var_1826,
)?;
object_1827.finish();
}
if let Some(var_1828) = &input.group_label_options {
#[allow(unused_mut)]
let mut object_1829 = object.key("GroupLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1829,
var_1828,
)?;
object_1829.finish();
}
if let Some(var_1830) = &input.size_label_options {
#[allow(unused_mut)]
let mut object_1831 = object.key("SizeLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1831,
var_1830,
)?;
object_1831.finish();
}
if let Some(var_1832) = &input.color_label_options {
#[allow(unused_mut)]
let mut object_1833 = object.key("ColorLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1833,
var_1832,
)?;
object_1833.finish();
}
if let Some(var_1834) = &input.color_scale {
#[allow(unused_mut)]
let mut object_1835 = object.key("ColorScale").start_object();
crate::json_ser::serialize_structure_crate_model_color_scale(&mut object_1835, var_1834)?;
object_1835.finish();
}
if let Some(var_1836) = &input.legend {
#[allow(unused_mut)]
let mut object_1837 = object.key("Legend").start_object();
crate::json_ser::serialize_structure_crate_model_legend_options(
&mut object_1837,
var_1836,
)?;
object_1837.finish();
}
if let Some(var_1838) = &input.data_labels {
#[allow(unused_mut)]
let mut object_1839 = object.key("DataLabels").start_object();
crate::json_ser::serialize_structure_crate_model_data_label_options(
&mut object_1839,
var_1838,
)?;
object_1839.finish();
}
if let Some(var_1840) = &input.tooltip {
#[allow(unused_mut)]
let mut object_1841 = object.key("Tooltip").start_object();
crate::json_ser::serialize_structure_crate_model_tooltip_options(
&mut object_1841,
var_1840,
)?;
object_1841.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_geospatial_map_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GeospatialMapConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1842) = &input.field_wells {
#[allow(unused_mut)]
let mut object_1843 = object.key("FieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_geospatial_map_field_wells(
&mut object_1843,
var_1842,
)?;
object_1843.finish();
}
if let Some(var_1844) = &input.legend {
#[allow(unused_mut)]
let mut object_1845 = object.key("Legend").start_object();
crate::json_ser::serialize_structure_crate_model_legend_options(
&mut object_1845,
var_1844,
)?;
object_1845.finish();
}
if let Some(var_1846) = &input.tooltip {
#[allow(unused_mut)]
let mut object_1847 = object.key("Tooltip").start_object();
crate::json_ser::serialize_structure_crate_model_tooltip_options(
&mut object_1847,
var_1846,
)?;
object_1847.finish();
}
if let Some(var_1848) = &input.window_options {
#[allow(unused_mut)]
let mut object_1849 = object.key("WindowOptions").start_object();
crate::json_ser::serialize_structure_crate_model_geospatial_window_options(
&mut object_1849,
var_1848,
)?;
object_1849.finish();
}
if let Some(var_1850) = &input.map_style_options {
#[allow(unused_mut)]
let mut object_1851 = object.key("MapStyleOptions").start_object();
crate::json_ser::serialize_structure_crate_model_geospatial_map_style_options(
&mut object_1851,
var_1850,
)?;
object_1851.finish();
}
if let Some(var_1852) = &input.point_style_options {
#[allow(unused_mut)]
let mut object_1853 = object.key("PointStyleOptions").start_object();
crate::json_ser::serialize_structure_crate_model_geospatial_point_style_options(
&mut object_1853,
var_1852,
)?;
object_1853.finish();
}
if let Some(var_1854) = &input.visual_palette {
#[allow(unused_mut)]
let mut object_1855 = object.key("VisualPalette").start_object();
crate::json_ser::serialize_structure_crate_model_visual_palette(
&mut object_1855,
var_1854,
)?;
object_1855.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filled_map_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilledMapConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1856) = &input.field_wells {
#[allow(unused_mut)]
let mut object_1857 = object.key("FieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_filled_map_field_wells(
&mut object_1857,
var_1856,
)?;
object_1857.finish();
}
if let Some(var_1858) = &input.sort_configuration {
#[allow(unused_mut)]
let mut object_1859 = object.key("SortConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_filled_map_sort_configuration(
&mut object_1859,
var_1858,
)?;
object_1859.finish();
}
if let Some(var_1860) = &input.legend {
#[allow(unused_mut)]
let mut object_1861 = object.key("Legend").start_object();
crate::json_ser::serialize_structure_crate_model_legend_options(
&mut object_1861,
var_1860,
)?;
object_1861.finish();
}
if let Some(var_1862) = &input.tooltip {
#[allow(unused_mut)]
let mut object_1863 = object.key("Tooltip").start_object();
crate::json_ser::serialize_structure_crate_model_tooltip_options(
&mut object_1863,
var_1862,
)?;
object_1863.finish();
}
if let Some(var_1864) = &input.window_options {
#[allow(unused_mut)]
let mut object_1865 = object.key("WindowOptions").start_object();
crate::json_ser::serialize_structure_crate_model_geospatial_window_options(
&mut object_1865,
var_1864,
)?;
object_1865.finish();
}
if let Some(var_1866) = &input.map_style_options {
#[allow(unused_mut)]
let mut object_1867 = object.key("MapStyleOptions").start_object();
crate::json_ser::serialize_structure_crate_model_geospatial_map_style_options(
&mut object_1867,
var_1866,
)?;
object_1867.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filled_map_conditional_formatting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilledMapConditionalFormatting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1868) = &input.conditional_formatting_options {
let mut array_1869 = object.key("ConditionalFormattingOptions").start_array();
for item_1870 in var_1868 {
{
#[allow(unused_mut)]
let mut object_1871 = array_1869.value().start_object();
crate::json_ser::serialize_structure_crate_model_filled_map_conditional_formatting_option(&mut object_1871, item_1870)?;
object_1871.finish();
}
}
array_1869.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_funnel_chart_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FunnelChartConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1872) = &input.field_wells {
#[allow(unused_mut)]
let mut object_1873 = object.key("FieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_funnel_chart_field_wells(
&mut object_1873,
var_1872,
)?;
object_1873.finish();
}
if let Some(var_1874) = &input.sort_configuration {
#[allow(unused_mut)]
let mut object_1875 = object.key("SortConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_funnel_chart_sort_configuration(
&mut object_1875,
var_1874,
)?;
object_1875.finish();
}
if let Some(var_1876) = &input.category_label_options {
#[allow(unused_mut)]
let mut object_1877 = object.key("CategoryLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1877,
var_1876,
)?;
object_1877.finish();
}
if let Some(var_1878) = &input.value_label_options {
#[allow(unused_mut)]
let mut object_1879 = object.key("ValueLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1879,
var_1878,
)?;
object_1879.finish();
}
if let Some(var_1880) = &input.tooltip {
#[allow(unused_mut)]
let mut object_1881 = object.key("Tooltip").start_object();
crate::json_ser::serialize_structure_crate_model_tooltip_options(
&mut object_1881,
var_1880,
)?;
object_1881.finish();
}
if let Some(var_1882) = &input.data_label_options {
#[allow(unused_mut)]
let mut object_1883 = object.key("DataLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_funnel_chart_data_label_options(
&mut object_1883,
var_1882,
)?;
object_1883.finish();
}
if let Some(var_1884) = &input.visual_palette {
#[allow(unused_mut)]
let mut object_1885 = object.key("VisualPalette").start_object();
crate::json_ser::serialize_structure_crate_model_visual_palette(
&mut object_1885,
var_1884,
)?;
object_1885.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_scatter_plot_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ScatterPlotConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1886) = &input.field_wells {
#[allow(unused_mut)]
let mut object_1887 = object.key("FieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_scatter_plot_field_wells(
&mut object_1887,
var_1886,
)?;
object_1887.finish();
}
if let Some(var_1888) = &input.x_axis_label_options {
#[allow(unused_mut)]
let mut object_1889 = object.key("XAxisLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1889,
var_1888,
)?;
object_1889.finish();
}
if let Some(var_1890) = &input.x_axis_display_options {
#[allow(unused_mut)]
let mut object_1891 = object.key("XAxisDisplayOptions").start_object();
crate::json_ser::serialize_structure_crate_model_axis_display_options(
&mut object_1891,
var_1890,
)?;
object_1891.finish();
}
if let Some(var_1892) = &input.y_axis_label_options {
#[allow(unused_mut)]
let mut object_1893 = object.key("YAxisLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1893,
var_1892,
)?;
object_1893.finish();
}
if let Some(var_1894) = &input.y_axis_display_options {
#[allow(unused_mut)]
let mut object_1895 = object.key("YAxisDisplayOptions").start_object();
crate::json_ser::serialize_structure_crate_model_axis_display_options(
&mut object_1895,
var_1894,
)?;
object_1895.finish();
}
if let Some(var_1896) = &input.legend {
#[allow(unused_mut)]
let mut object_1897 = object.key("Legend").start_object();
crate::json_ser::serialize_structure_crate_model_legend_options(
&mut object_1897,
var_1896,
)?;
object_1897.finish();
}
if let Some(var_1898) = &input.data_labels {
#[allow(unused_mut)]
let mut object_1899 = object.key("DataLabels").start_object();
crate::json_ser::serialize_structure_crate_model_data_label_options(
&mut object_1899,
var_1898,
)?;
object_1899.finish();
}
if let Some(var_1900) = &input.tooltip {
#[allow(unused_mut)]
let mut object_1901 = object.key("Tooltip").start_object();
crate::json_ser::serialize_structure_crate_model_tooltip_options(
&mut object_1901,
var_1900,
)?;
object_1901.finish();
}
if let Some(var_1902) = &input.visual_palette {
#[allow(unused_mut)]
let mut object_1903 = object.key("VisualPalette").start_object();
crate::json_ser::serialize_structure_crate_model_visual_palette(
&mut object_1903,
var_1902,
)?;
object_1903.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_combo_chart_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComboChartConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1904) = &input.field_wells {
#[allow(unused_mut)]
let mut object_1905 = object.key("FieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_combo_chart_field_wells(
&mut object_1905,
var_1904,
)?;
object_1905.finish();
}
if let Some(var_1906) = &input.sort_configuration {
#[allow(unused_mut)]
let mut object_1907 = object.key("SortConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_combo_chart_sort_configuration(
&mut object_1907,
var_1906,
)?;
object_1907.finish();
}
if let Some(var_1908) = &input.bars_arrangement {
object.key("BarsArrangement").string(var_1908.as_str());
}
if let Some(var_1909) = &input.category_axis {
#[allow(unused_mut)]
let mut object_1910 = object.key("CategoryAxis").start_object();
crate::json_ser::serialize_structure_crate_model_axis_display_options(
&mut object_1910,
var_1909,
)?;
object_1910.finish();
}
if let Some(var_1911) = &input.category_label_options {
#[allow(unused_mut)]
let mut object_1912 = object.key("CategoryLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1912,
var_1911,
)?;
object_1912.finish();
}
if let Some(var_1913) = &input.primary_y_axis_display_options {
#[allow(unused_mut)]
let mut object_1914 = object.key("PrimaryYAxisDisplayOptions").start_object();
crate::json_ser::serialize_structure_crate_model_axis_display_options(
&mut object_1914,
var_1913,
)?;
object_1914.finish();
}
if let Some(var_1915) = &input.primary_y_axis_label_options {
#[allow(unused_mut)]
let mut object_1916 = object.key("PrimaryYAxisLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1916,
var_1915,
)?;
object_1916.finish();
}
if let Some(var_1917) = &input.secondary_y_axis_display_options {
#[allow(unused_mut)]
let mut object_1918 = object.key("SecondaryYAxisDisplayOptions").start_object();
crate::json_ser::serialize_structure_crate_model_axis_display_options(
&mut object_1918,
var_1917,
)?;
object_1918.finish();
}
if let Some(var_1919) = &input.secondary_y_axis_label_options {
#[allow(unused_mut)]
let mut object_1920 = object.key("SecondaryYAxisLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1920,
var_1919,
)?;
object_1920.finish();
}
if let Some(var_1921) = &input.color_label_options {
#[allow(unused_mut)]
let mut object_1922 = object.key("ColorLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1922,
var_1921,
)?;
object_1922.finish();
}
if let Some(var_1923) = &input.legend {
#[allow(unused_mut)]
let mut object_1924 = object.key("Legend").start_object();
crate::json_ser::serialize_structure_crate_model_legend_options(
&mut object_1924,
var_1923,
)?;
object_1924.finish();
}
if let Some(var_1925) = &input.bar_data_labels {
#[allow(unused_mut)]
let mut object_1926 = object.key("BarDataLabels").start_object();
crate::json_ser::serialize_structure_crate_model_data_label_options(
&mut object_1926,
var_1925,
)?;
object_1926.finish();
}
if let Some(var_1927) = &input.line_data_labels {
#[allow(unused_mut)]
let mut object_1928 = object.key("LineDataLabels").start_object();
crate::json_ser::serialize_structure_crate_model_data_label_options(
&mut object_1928,
var_1927,
)?;
object_1928.finish();
}
if let Some(var_1929) = &input.tooltip {
#[allow(unused_mut)]
let mut object_1930 = object.key("Tooltip").start_object();
crate::json_ser::serialize_structure_crate_model_tooltip_options(
&mut object_1930,
var_1929,
)?;
object_1930.finish();
}
if let Some(var_1931) = &input.reference_lines {
let mut array_1932 = object.key("ReferenceLines").start_array();
for item_1933 in var_1931 {
{
#[allow(unused_mut)]
let mut object_1934 = array_1932.value().start_object();
crate::json_ser::serialize_structure_crate_model_reference_line(
&mut object_1934,
item_1933,
)?;
object_1934.finish();
}
}
array_1932.finish();
}
if let Some(var_1935) = &input.visual_palette {
#[allow(unused_mut)]
let mut object_1936 = object.key("VisualPalette").start_object();
crate::json_ser::serialize_structure_crate_model_visual_palette(
&mut object_1936,
var_1935,
)?;
object_1936.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_box_plot_chart_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BoxPlotChartConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1937) = &input.field_wells {
#[allow(unused_mut)]
let mut object_1938 = object.key("FieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_box_plot_field_wells(
&mut object_1938,
var_1937,
)?;
object_1938.finish();
}
if let Some(var_1939) = &input.sort_configuration {
#[allow(unused_mut)]
let mut object_1940 = object.key("SortConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_box_plot_sort_configuration(
&mut object_1940,
var_1939,
)?;
object_1940.finish();
}
if let Some(var_1941) = &input.box_plot_options {
#[allow(unused_mut)]
let mut object_1942 = object.key("BoxPlotOptions").start_object();
crate::json_ser::serialize_structure_crate_model_box_plot_options(
&mut object_1942,
var_1941,
)?;
object_1942.finish();
}
if let Some(var_1943) = &input.category_axis {
#[allow(unused_mut)]
let mut object_1944 = object.key("CategoryAxis").start_object();
crate::json_ser::serialize_structure_crate_model_axis_display_options(
&mut object_1944,
var_1943,
)?;
object_1944.finish();
}
if let Some(var_1945) = &input.category_label_options {
#[allow(unused_mut)]
let mut object_1946 = object.key("CategoryLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1946,
var_1945,
)?;
object_1946.finish();
}
if let Some(var_1947) = &input.primary_y_axis_display_options {
#[allow(unused_mut)]
let mut object_1948 = object.key("PrimaryYAxisDisplayOptions").start_object();
crate::json_ser::serialize_structure_crate_model_axis_display_options(
&mut object_1948,
var_1947,
)?;
object_1948.finish();
}
if let Some(var_1949) = &input.primary_y_axis_label_options {
#[allow(unused_mut)]
let mut object_1950 = object.key("PrimaryYAxisLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1950,
var_1949,
)?;
object_1950.finish();
}
if let Some(var_1951) = &input.legend {
#[allow(unused_mut)]
let mut object_1952 = object.key("Legend").start_object();
crate::json_ser::serialize_structure_crate_model_legend_options(
&mut object_1952,
var_1951,
)?;
object_1952.finish();
}
if let Some(var_1953) = &input.tooltip {
#[allow(unused_mut)]
let mut object_1954 = object.key("Tooltip").start_object();
crate::json_ser::serialize_structure_crate_model_tooltip_options(
&mut object_1954,
var_1953,
)?;
object_1954.finish();
}
if let Some(var_1955) = &input.reference_lines {
let mut array_1956 = object.key("ReferenceLines").start_array();
for item_1957 in var_1955 {
{
#[allow(unused_mut)]
let mut object_1958 = array_1956.value().start_object();
crate::json_ser::serialize_structure_crate_model_reference_line(
&mut object_1958,
item_1957,
)?;
object_1958.finish();
}
}
array_1956.finish();
}
if let Some(var_1959) = &input.visual_palette {
#[allow(unused_mut)]
let mut object_1960 = object.key("VisualPalette").start_object();
crate::json_ser::serialize_structure_crate_model_visual_palette(
&mut object_1960,
var_1959,
)?;
object_1960.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_waterfall_chart_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WaterfallChartConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1961) = &input.field_wells {
#[allow(unused_mut)]
let mut object_1962 = object.key("FieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_waterfall_chart_field_wells(
&mut object_1962,
var_1961,
)?;
object_1962.finish();
}
if let Some(var_1963) = &input.sort_configuration {
#[allow(unused_mut)]
let mut object_1964 = object.key("SortConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_waterfall_chart_sort_configuration(
&mut object_1964,
var_1963,
)?;
object_1964.finish();
}
if let Some(var_1965) = &input.waterfall_chart_options {
#[allow(unused_mut)]
let mut object_1966 = object.key("WaterfallChartOptions").start_object();
crate::json_ser::serialize_structure_crate_model_waterfall_chart_options(
&mut object_1966,
var_1965,
)?;
object_1966.finish();
}
if let Some(var_1967) = &input.category_axis_label_options {
#[allow(unused_mut)]
let mut object_1968 = object.key("CategoryAxisLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1968,
var_1967,
)?;
object_1968.finish();
}
if let Some(var_1969) = &input.category_axis_display_options {
#[allow(unused_mut)]
let mut object_1970 = object.key("CategoryAxisDisplayOptions").start_object();
crate::json_ser::serialize_structure_crate_model_axis_display_options(
&mut object_1970,
var_1969,
)?;
object_1970.finish();
}
if let Some(var_1971) = &input.primary_y_axis_label_options {
#[allow(unused_mut)]
let mut object_1972 = object.key("PrimaryYAxisLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1972,
var_1971,
)?;
object_1972.finish();
}
if let Some(var_1973) = &input.primary_y_axis_display_options {
#[allow(unused_mut)]
let mut object_1974 = object.key("PrimaryYAxisDisplayOptions").start_object();
crate::json_ser::serialize_structure_crate_model_axis_display_options(
&mut object_1974,
var_1973,
)?;
object_1974.finish();
}
if let Some(var_1975) = &input.legend {
#[allow(unused_mut)]
let mut object_1976 = object.key("Legend").start_object();
crate::json_ser::serialize_structure_crate_model_legend_options(
&mut object_1976,
var_1975,
)?;
object_1976.finish();
}
if let Some(var_1977) = &input.data_labels {
#[allow(unused_mut)]
let mut object_1978 = object.key("DataLabels").start_object();
crate::json_ser::serialize_structure_crate_model_data_label_options(
&mut object_1978,
var_1977,
)?;
object_1978.finish();
}
if let Some(var_1979) = &input.visual_palette {
#[allow(unused_mut)]
let mut object_1980 = object.key("VisualPalette").start_object();
crate::json_ser::serialize_structure_crate_model_visual_palette(
&mut object_1980,
var_1979,
)?;
object_1980.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_histogram_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HistogramConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1981) = &input.field_wells {
#[allow(unused_mut)]
let mut object_1982 = object.key("FieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_histogram_field_wells(
&mut object_1982,
var_1981,
)?;
object_1982.finish();
}
if let Some(var_1983) = &input.x_axis_display_options {
#[allow(unused_mut)]
let mut object_1984 = object.key("XAxisDisplayOptions").start_object();
crate::json_ser::serialize_structure_crate_model_axis_display_options(
&mut object_1984,
var_1983,
)?;
object_1984.finish();
}
if let Some(var_1985) = &input.x_axis_label_options {
#[allow(unused_mut)]
let mut object_1986 = object.key("XAxisLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_1986,
var_1985,
)?;
object_1986.finish();
}
if let Some(var_1987) = &input.y_axis_display_options {
#[allow(unused_mut)]
let mut object_1988 = object.key("YAxisDisplayOptions").start_object();
crate::json_ser::serialize_structure_crate_model_axis_display_options(
&mut object_1988,
var_1987,
)?;
object_1988.finish();
}
if let Some(var_1989) = &input.bin_options {
#[allow(unused_mut)]
let mut object_1990 = object.key("BinOptions").start_object();
crate::json_ser::serialize_structure_crate_model_histogram_bin_options(
&mut object_1990,
var_1989,
)?;
object_1990.finish();
}
if let Some(var_1991) = &input.data_labels {
#[allow(unused_mut)]
let mut object_1992 = object.key("DataLabels").start_object();
crate::json_ser::serialize_structure_crate_model_data_label_options(
&mut object_1992,
var_1991,
)?;
object_1992.finish();
}
if let Some(var_1993) = &input.tooltip {
#[allow(unused_mut)]
let mut object_1994 = object.key("Tooltip").start_object();
crate::json_ser::serialize_structure_crate_model_tooltip_options(
&mut object_1994,
var_1993,
)?;
object_1994.finish();
}
if let Some(var_1995) = &input.visual_palette {
#[allow(unused_mut)]
let mut object_1996 = object.key("VisualPalette").start_object();
crate::json_ser::serialize_structure_crate_model_visual_palette(
&mut object_1996,
var_1995,
)?;
object_1996.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_word_cloud_chart_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WordCloudChartConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1997) = &input.field_wells {
#[allow(unused_mut)]
let mut object_1998 = object.key("FieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_word_cloud_field_wells(
&mut object_1998,
var_1997,
)?;
object_1998.finish();
}
if let Some(var_1999) = &input.sort_configuration {
#[allow(unused_mut)]
let mut object_2000 = object.key("SortConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_word_cloud_sort_configuration(
&mut object_2000,
var_1999,
)?;
object_2000.finish();
}
if let Some(var_2001) = &input.category_label_options {
#[allow(unused_mut)]
let mut object_2002 = object.key("CategoryLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_chart_axis_label_options(
&mut object_2002,
var_2001,
)?;
object_2002.finish();
}
if let Some(var_2003) = &input.word_cloud_options {
#[allow(unused_mut)]
let mut object_2004 = object.key("WordCloudOptions").start_object();
crate::json_ser::serialize_structure_crate_model_word_cloud_options(
&mut object_2004,
var_2003,
)?;
object_2004.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_insight_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InsightConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2005) = &input.computations {
let mut array_2006 = object.key("Computations").start_array();
for item_2007 in var_2005 {
{
#[allow(unused_mut)]
let mut object_2008 = array_2006.value().start_object();
crate::json_ser::serialize_structure_crate_model_computation(
&mut object_2008,
item_2007,
)?;
object_2008.finish();
}
}
array_2006.finish();
}
if let Some(var_2009) = &input.custom_narrative {
#[allow(unused_mut)]
let mut object_2010 = object.key("CustomNarrative").start_object();
crate::json_ser::serialize_structure_crate_model_custom_narrative_options(
&mut object_2010,
var_2009,
)?;
object_2010.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sankey_diagram_chart_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SankeyDiagramChartConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2011) = &input.field_wells {
#[allow(unused_mut)]
let mut object_2012 = object.key("FieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_sankey_diagram_field_wells(
&mut object_2012,
var_2011,
)?;
object_2012.finish();
}
if let Some(var_2013) = &input.sort_configuration {
#[allow(unused_mut)]
let mut object_2014 = object.key("SortConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_sankey_diagram_sort_configuration(
&mut object_2014,
var_2013,
)?;
object_2014.finish();
}
if let Some(var_2015) = &input.data_labels {
#[allow(unused_mut)]
let mut object_2016 = object.key("DataLabels").start_object();
crate::json_ser::serialize_structure_crate_model_data_label_options(
&mut object_2016,
var_2015,
)?;
object_2016.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_content_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomContentConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2017) = &input.content_url {
object.key("ContentUrl").string(var_2017.as_str());
}
if let Some(var_2018) = &input.content_type {
object.key("ContentType").string(var_2018.as_str());
}
if let Some(var_2019) = &input.image_scaling {
object.key("ImageScaling").string(var_2019.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_grid_layout_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GridLayoutConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2020) = &input.elements {
let mut array_2021 = object.key("Elements").start_array();
for item_2022 in var_2020 {
{
#[allow(unused_mut)]
let mut object_2023 = array_2021.value().start_object();
crate::json_ser::serialize_structure_crate_model_grid_layout_element(
&mut object_2023,
item_2022,
)?;
object_2023.finish();
}
}
array_2021.finish();
}
if let Some(var_2024) = &input.canvas_size_options {
#[allow(unused_mut)]
let mut object_2025 = object.key("CanvasSizeOptions").start_object();
crate::json_ser::serialize_structure_crate_model_grid_layout_canvas_size_options(
&mut object_2025,
var_2024,
)?;
object_2025.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_free_form_layout_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FreeFormLayoutConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2026) = &input.elements {
let mut array_2027 = object.key("Elements").start_array();
for item_2028 in var_2026 {
{
#[allow(unused_mut)]
let mut object_2029 = array_2027.value().start_object();
crate::json_ser::serialize_structure_crate_model_free_form_layout_element(
&mut object_2029,
item_2028,
)?;
object_2029.finish();
}
}
array_2027.finish();
}
if let Some(var_2030) = &input.canvas_size_options {
#[allow(unused_mut)]
let mut object_2031 = object.key("CanvasSizeOptions").start_object();
crate::json_ser::serialize_structure_crate_model_free_form_layout_canvas_size_options(
&mut object_2031,
var_2030,
)?;
object_2031.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_section_based_layout_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SectionBasedLayoutConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2032) = &input.header_sections {
let mut array_2033 = object.key("HeaderSections").start_array();
for item_2034 in var_2032 {
{
#[allow(unused_mut)]
let mut object_2035 = array_2033.value().start_object();
crate::json_ser::serialize_structure_crate_model_header_footer_section_configuration(&mut object_2035, item_2034)?;
object_2035.finish();
}
}
array_2033.finish();
}
if let Some(var_2036) = &input.body_sections {
let mut array_2037 = object.key("BodySections").start_array();
for item_2038 in var_2036 {
{
#[allow(unused_mut)]
let mut object_2039 = array_2037.value().start_object();
crate::json_ser::serialize_structure_crate_model_body_section_configuration(
&mut object_2039,
item_2038,
)?;
object_2039.finish();
}
}
array_2037.finish();
}
if let Some(var_2040) = &input.footer_sections {
let mut array_2041 = object.key("FooterSections").start_array();
for item_2042 in var_2040 {
{
#[allow(unused_mut)]
let mut object_2043 = array_2041.value().start_object();
crate::json_ser::serialize_structure_crate_model_header_footer_section_configuration(&mut object_2043, item_2042)?;
object_2043.finish();
}
}
array_2041.finish();
}
if let Some(var_2044) = &input.canvas_size_options {
#[allow(unused_mut)]
let mut object_2045 = object.key("CanvasSizeOptions").start_object();
crate::json_ser::serialize_structure_crate_model_section_based_layout_canvas_size_options(
&mut object_2045,
var_2044,
)?;
object_2045.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_dynamic_default_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DynamicDefaultValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2046) = &input.user_name_column {
#[allow(unused_mut)]
let mut object_2047 = object.key("UserNameColumn").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_2047,
var_2046,
)?;
object_2047.finish();
}
if let Some(var_2048) = &input.group_name_column {
#[allow(unused_mut)]
let mut object_2049 = object.key("GroupNameColumn").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_2049,
var_2048,
)?;
object_2049.finish();
}
if let Some(var_2050) = &input.default_value_column {
#[allow(unused_mut)]
let mut object_2051 = object.key("DefaultValueColumn").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_2051,
var_2050,
)?;
object_2051.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_rolling_date_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RollingDateConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2052) = &input.data_set_identifier {
object.key("DataSetIdentifier").string(var_2052.as_str());
}
if let Some(var_2053) = &input.expression {
object.key("Expression").string(var_2053.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_category_filter_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CategoryFilterConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2054) = &input.filter_list_configuration {
#[allow(unused_mut)]
let mut object_2055 = object.key("FilterListConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_filter_list_configuration(
&mut object_2055,
var_2054,
)?;
object_2055.finish();
}
if let Some(var_2056) = &input.custom_filter_list_configuration {
#[allow(unused_mut)]
let mut object_2057 = object.key("CustomFilterListConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_custom_filter_list_configuration(
&mut object_2057,
var_2056,
)?;
object_2057.finish();
}
if let Some(var_2058) = &input.custom_filter_configuration {
#[allow(unused_mut)]
let mut object_2059 = object.key("CustomFilterConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_custom_filter_configuration(
&mut object_2059,
var_2058,
)?;
object_2059.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_numeric_range_filter_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NumericRangeFilterValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2060) = &input.static_value {
object.key("StaticValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_2060).into()),
);
}
if let Some(var_2061) = &input.parameter {
object.key("Parameter").string(var_2061.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aggregation_function(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AggregationFunction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2062) = &input.numerical_aggregation_function {
#[allow(unused_mut)]
let mut object_2063 = object.key("NumericalAggregationFunction").start_object();
crate::json_ser::serialize_structure_crate_model_numerical_aggregation_function(
&mut object_2063,
var_2062,
)?;
object_2063.finish();
}
if let Some(var_2064) = &input.categorical_aggregation_function {
object
.key("CategoricalAggregationFunction")
.string(var_2064.as_str());
}
if let Some(var_2065) = &input.date_aggregation_function {
object
.key("DateAggregationFunction")
.string(var_2065.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_time_range_filter_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimeRangeFilterValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2066) = &input.static_value {
object
.key("StaticValue")
.date_time(var_2066, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_2067) = &input.rolling_date {
#[allow(unused_mut)]
let mut object_2068 = object.key("RollingDate").start_object();
crate::json_ser::serialize_structure_crate_model_rolling_date_configuration(
&mut object_2068,
var_2067,
)?;
object_2068.finish();
}
if let Some(var_2069) = &input.parameter {
object.key("Parameter").string(var_2069.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_exclude_period_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExcludePeriodConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2070) = &input.amount {
object.key("Amount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2070).into()),
);
}
if let Some(var_2071) = &input.granularity {
object.key("Granularity").string(var_2071.as_str());
}
if let Some(var_2072) = &input.status {
object.key("Status").string(var_2072.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_anchor_date_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AnchorDateConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2073) = &input.anchor_option {
object.key("AnchorOption").string(var_2073.as_str());
}
if let Some(var_2074) = &input.parameter_name {
object.key("ParameterName").string(var_2074.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aggregation_sort_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AggregationSortConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2075) = &input.column {
#[allow(unused_mut)]
let mut object_2076 = object.key("Column").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_2076,
var_2075,
)?;
object_2076.finish();
}
if let Some(var_2077) = &input.sort_direction {
object.key("SortDirection").string(var_2077.as_str());
}
if let Some(var_2078) = &input.aggregation_function {
#[allow(unused_mut)]
let mut object_2079 = object.key("AggregationFunction").start_object();
crate::json_ser::serialize_structure_crate_model_aggregation_function(
&mut object_2079,
var_2078,
)?;
object_2079.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sheet_visual_scoping_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SheetVisualScopingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2080) = &input.sheet_id {
object.key("SheetId").string(var_2080.as_str());
}
if let Some(var_2081) = &input.scope {
object.key("Scope").string(var_2081.as_str());
}
if let Some(var_2082) = &input.visual_ids {
let mut array_2083 = object.key("VisualIds").start_array();
for item_2084 in var_2082 {
{
array_2083.value().string(item_2084.as_str());
}
}
array_2083.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_null_value_format_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NullValueFormatConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2085) = &input.null_string {
object.key("NullString").string(var_2085.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_numeric_format_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NumericFormatConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2086) = &input.number_display_format_configuration {
#[allow(unused_mut)]
let mut object_2087 = object
.key("NumberDisplayFormatConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_number_display_format_configuration(
&mut object_2087,
var_2086,
)?;
object_2087.finish();
}
if let Some(var_2088) = &input.currency_display_format_configuration {
#[allow(unused_mut)]
let mut object_2089 = object
.key("CurrencyDisplayFormatConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_currency_display_format_configuration(
&mut object_2089,
var_2088,
)?;
object_2089.finish();
}
if let Some(var_2090) = &input.percentage_display_format_configuration {
#[allow(unused_mut)]
let mut object_2091 = object
.key("PercentageDisplayFormatConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_percentage_display_format_configuration(
&mut object_2091,
var_2090,
)?;
object_2091.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_default_grid_layout_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DefaultGridLayoutConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2092) = &input.canvas_size_options {
#[allow(unused_mut)]
let mut object_2093 = object.key("CanvasSizeOptions").start_object();
crate::json_ser::serialize_structure_crate_model_grid_layout_canvas_size_options(
&mut object_2093,
var_2092,
)?;
object_2093.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_default_free_form_layout_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DefaultFreeFormLayoutConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2094) = &input.canvas_size_options {
#[allow(unused_mut)]
let mut object_2095 = object.key("CanvasSizeOptions").start_object();
crate::json_ser::serialize_structure_crate_model_free_form_layout_canvas_size_options(
&mut object_2095,
var_2094,
)?;
object_2095.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_default_section_based_layout_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DefaultSectionBasedLayoutConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2096) = &input.canvas_size_options {
#[allow(unused_mut)]
let mut object_2097 = object.key("CanvasSizeOptions").start_object();
crate::json_ser::serialize_structure_crate_model_section_based_layout_canvas_size_options(
&mut object_2097,
var_2096,
)?;
object_2097.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_column_description(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ColumnDescription,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2098) = &input.text {
object.key("Text").string(var_2098.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_label_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LabelOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2099) = &input.visibility {
object.key("Visibility").string(var_2099.as_str());
}
if let Some(var_2100) = &input.font_configuration {
#[allow(unused_mut)]
let mut object_2101 = object.key("FontConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_font_configuration(
&mut object_2101,
var_2100,
)?;
object_2101.finish();
}
if let Some(var_2102) = &input.custom_label {
object.key("CustomLabel").string(var_2102.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_list_control_search_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListControlSearchOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2103) = &input.visibility {
object.key("Visibility").string(var_2103.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_list_control_select_all_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListControlSelectAllOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2104) = &input.visibility {
object.key("Visibility").string(var_2104.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_cascading_control_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CascadingControlSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2105) = &input.source_sheet_control_id {
object.key("SourceSheetControlId").string(var_2105.as_str());
}
if let Some(var_2106) = &input.column_to_match {
#[allow(unused_mut)]
let mut object_2107 = object.key("ColumnToMatch").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_2107,
var_2106,
)?;
object_2107.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_text_control_placeholder_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TextControlPlaceholderOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2108) = &input.visibility {
object.key("Visibility").string(var_2108.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_short_format_text(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ShortFormatText,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2109) = &input.plain_text {
object.key("PlainText").string(var_2109.as_str());
}
if let Some(var_2110) = &input.rich_text {
object.key("RichText").string(var_2110.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_long_format_text(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LongFormatText,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2111) = &input.plain_text {
object.key("PlainText").string(var_2111.as_str());
}
if let Some(var_2112) = &input.rich_text {
object.key("RichText").string(var_2112.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_table_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2113) = &input.table_aggregated_field_wells {
#[allow(unused_mut)]
let mut object_2114 = object.key("TableAggregatedFieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_table_aggregated_field_wells(
&mut object_2114,
var_2113,
)?;
object_2114.finish();
}
if let Some(var_2115) = &input.table_unaggregated_field_wells {
#[allow(unused_mut)]
let mut object_2116 = object.key("TableUnaggregatedFieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_table_unaggregated_field_wells(
&mut object_2116,
var_2115,
)?;
object_2116.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_table_sort_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableSortConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2117) = &input.row_sort {
let mut array_2118 = object.key("RowSort").start_array();
for item_2119 in var_2117 {
{
#[allow(unused_mut)]
let mut object_2120 = array_2118.value().start_object();
crate::json_ser::serialize_structure_crate_model_field_sort_options(
&mut object_2120,
item_2119,
)?;
object_2120.finish();
}
}
array_2118.finish();
}
if let Some(var_2121) = &input.pagination_configuration {
#[allow(unused_mut)]
let mut object_2122 = object.key("PaginationConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_pagination_configuration(
&mut object_2122,
var_2121,
)?;
object_2122.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_table_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2123) = &input.orientation {
object.key("Orientation").string(var_2123.as_str());
}
if let Some(var_2124) = &input.header_style {
#[allow(unused_mut)]
let mut object_2125 = object.key("HeaderStyle").start_object();
crate::json_ser::serialize_structure_crate_model_table_cell_style(
&mut object_2125,
var_2124,
)?;
object_2125.finish();
}
if let Some(var_2126) = &input.cell_style {
#[allow(unused_mut)]
let mut object_2127 = object.key("CellStyle").start_object();
crate::json_ser::serialize_structure_crate_model_table_cell_style(
&mut object_2127,
var_2126,
)?;
object_2127.finish();
}
if let Some(var_2128) = &input.row_alternate_color_options {
#[allow(unused_mut)]
let mut object_2129 = object.key("RowAlternateColorOptions").start_object();
crate::json_ser::serialize_structure_crate_model_row_alternate_color_options(
&mut object_2129,
var_2128,
)?;
object_2129.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_total_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TotalOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2130) = &input.totals_visibility {
object.key("TotalsVisibility").string(var_2130.as_str());
}
if let Some(var_2131) = &input.placement {
object.key("Placement").string(var_2131.as_str());
}
if let Some(var_2132) = &input.scroll_status {
object.key("ScrollStatus").string(var_2132.as_str());
}
if let Some(var_2133) = &input.custom_label {
object.key("CustomLabel").string(var_2133.as_str());
}
if let Some(var_2134) = &input.total_cell_style {
#[allow(unused_mut)]
let mut object_2135 = object.key("TotalCellStyle").start_object();
crate::json_ser::serialize_structure_crate_model_table_cell_style(
&mut object_2135,
var_2134,
)?;
object_2135.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_table_field_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableFieldOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2136) = &input.selected_field_options {
let mut array_2137 = object.key("SelectedFieldOptions").start_array();
for item_2138 in var_2136 {
{
#[allow(unused_mut)]
let mut object_2139 = array_2137.value().start_object();
crate::json_ser::serialize_structure_crate_model_table_field_option(
&mut object_2139,
item_2138,
)?;
object_2139.finish();
}
}
array_2137.finish();
}
if let Some(var_2140) = &input.order {
let mut array_2141 = object.key("Order").start_array();
for item_2142 in var_2140 {
{
array_2141.value().string(item_2142.as_str());
}
}
array_2141.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_table_paginated_report_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TablePaginatedReportOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2143) = &input.vertical_overflow_visibility {
object
.key("VerticalOverflowVisibility")
.string(var_2143.as_str());
}
if let Some(var_2144) = &input.overflow_column_header_visibility {
object
.key("OverflowColumnHeaderVisibility")
.string(var_2144.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_table_inline_visualization(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableInlineVisualization,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2145) = &input.data_bars {
#[allow(unused_mut)]
let mut object_2146 = object.key("DataBars").start_object();
crate::json_ser::serialize_structure_crate_model_data_bars_options(
&mut object_2146,
var_2145,
)?;
object_2146.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_table_conditional_formatting_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableConditionalFormattingOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2147) = &input.cell {
#[allow(unused_mut)]
let mut object_2148 = object.key("Cell").start_object();
crate::json_ser::serialize_structure_crate_model_table_cell_conditional_formatting(
&mut object_2148,
var_2147,
)?;
object_2148.finish();
}
if let Some(var_2149) = &input.row {
#[allow(unused_mut)]
let mut object_2150 = object.key("Row").start_object();
crate::json_ser::serialize_structure_crate_model_table_row_conditional_formatting(
&mut object_2150,
var_2149,
)?;
object_2150.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_visual_custom_action_operation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VisualCustomActionOperation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2151) = &input.filter_operation {
#[allow(unused_mut)]
let mut object_2152 = object.key("FilterOperation").start_object();
crate::json_ser::serialize_structure_crate_model_custom_action_filter_operation(
&mut object_2152,
var_2151,
)?;
object_2152.finish();
}
if let Some(var_2153) = &input.navigation_operation {
#[allow(unused_mut)]
let mut object_2154 = object.key("NavigationOperation").start_object();
crate::json_ser::serialize_structure_crate_model_custom_action_navigation_operation(
&mut object_2154,
var_2153,
)?;
object_2154.finish();
}
if let Some(var_2155) = &input.url_operation {
#[allow(unused_mut)]
let mut object_2156 = object.key("URLOperation").start_object();
crate::json_ser::serialize_structure_crate_model_custom_action_url_operation(
&mut object_2156,
var_2155,
)?;
object_2156.finish();
}
if let Some(var_2157) = &input.set_parameters_operation {
#[allow(unused_mut)]
let mut object_2158 = object.key("SetParametersOperation").start_object();
crate::json_ser::serialize_structure_crate_model_custom_action_set_parameters_operation(
&mut object_2158,
var_2157,
)?;
object_2158.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pivot_table_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PivotTableFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2159) = &input.pivot_table_aggregated_field_wells {
#[allow(unused_mut)]
let mut object_2160 = object.key("PivotTableAggregatedFieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_pivot_table_aggregated_field_wells(
&mut object_2160,
var_2159,
)?;
object_2160.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pivot_table_sort_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PivotTableSortConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2161) = &input.field_sort_options {
let mut array_2162 = object.key("FieldSortOptions").start_array();
for item_2163 in var_2161 {
{
#[allow(unused_mut)]
let mut object_2164 = array_2162.value().start_object();
crate::json_ser::serialize_structure_crate_model_pivot_field_sort_options(
&mut object_2164,
item_2163,
)?;
object_2164.finish();
}
}
array_2162.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pivot_table_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PivotTableOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2165) = &input.metric_placement {
object.key("MetricPlacement").string(var_2165.as_str());
}
if let Some(var_2166) = &input.single_metric_visibility {
object
.key("SingleMetricVisibility")
.string(var_2166.as_str());
}
if let Some(var_2167) = &input.column_names_visibility {
object
.key("ColumnNamesVisibility")
.string(var_2167.as_str());
}
if let Some(var_2168) = &input.toggle_buttons_visibility {
object
.key("ToggleButtonsVisibility")
.string(var_2168.as_str());
}
if let Some(var_2169) = &input.column_header_style {
#[allow(unused_mut)]
let mut object_2170 = object.key("ColumnHeaderStyle").start_object();
crate::json_ser::serialize_structure_crate_model_table_cell_style(
&mut object_2170,
var_2169,
)?;
object_2170.finish();
}
if let Some(var_2171) = &input.row_header_style {
#[allow(unused_mut)]
let mut object_2172 = object.key("RowHeaderStyle").start_object();
crate::json_ser::serialize_structure_crate_model_table_cell_style(
&mut object_2172,
var_2171,
)?;
object_2172.finish();
}
if let Some(var_2173) = &input.cell_style {
#[allow(unused_mut)]
let mut object_2174 = object.key("CellStyle").start_object();
crate::json_ser::serialize_structure_crate_model_table_cell_style(
&mut object_2174,
var_2173,
)?;
object_2174.finish();
}
if let Some(var_2175) = &input.row_field_names_style {
#[allow(unused_mut)]
let mut object_2176 = object.key("RowFieldNamesStyle").start_object();
crate::json_ser::serialize_structure_crate_model_table_cell_style(
&mut object_2176,
var_2175,
)?;
object_2176.finish();
}
if let Some(var_2177) = &input.row_alternate_color_options {
#[allow(unused_mut)]
let mut object_2178 = object.key("RowAlternateColorOptions").start_object();
crate::json_ser::serialize_structure_crate_model_row_alternate_color_options(
&mut object_2178,
var_2177,
)?;
object_2178.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pivot_table_total_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PivotTableTotalOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2179) = &input.row_subtotal_options {
#[allow(unused_mut)]
let mut object_2180 = object.key("RowSubtotalOptions").start_object();
crate::json_ser::serialize_structure_crate_model_subtotal_options(
&mut object_2180,
var_2179,
)?;
object_2180.finish();
}
if let Some(var_2181) = &input.column_subtotal_options {
#[allow(unused_mut)]
let mut object_2182 = object.key("ColumnSubtotalOptions").start_object();
crate::json_ser::serialize_structure_crate_model_subtotal_options(
&mut object_2182,
var_2181,
)?;
object_2182.finish();
}
if let Some(var_2183) = &input.row_total_options {
#[allow(unused_mut)]
let mut object_2184 = object.key("RowTotalOptions").start_object();
crate::json_ser::serialize_structure_crate_model_pivot_total_options(
&mut object_2184,
var_2183,
)?;
object_2184.finish();
}
if let Some(var_2185) = &input.column_total_options {
#[allow(unused_mut)]
let mut object_2186 = object.key("ColumnTotalOptions").start_object();
crate::json_ser::serialize_structure_crate_model_pivot_total_options(
&mut object_2186,
var_2185,
)?;
object_2186.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pivot_table_field_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PivotTableFieldOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2187) = &input.selected_field_options {
let mut array_2188 = object.key("SelectedFieldOptions").start_array();
for item_2189 in var_2187 {
{
#[allow(unused_mut)]
let mut object_2190 = array_2188.value().start_object();
crate::json_ser::serialize_structure_crate_model_pivot_table_field_option(
&mut object_2190,
item_2189,
)?;
object_2190.finish();
}
}
array_2188.finish();
}
if let Some(var_2191) = &input.data_path_options {
let mut array_2192 = object.key("DataPathOptions").start_array();
for item_2193 in var_2191 {
{
#[allow(unused_mut)]
let mut object_2194 = array_2192.value().start_object();
crate::json_ser::serialize_structure_crate_model_pivot_table_data_path_option(
&mut object_2194,
item_2193,
)?;
object_2194.finish();
}
}
array_2192.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pivot_table_paginated_report_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PivotTablePaginatedReportOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2195) = &input.vertical_overflow_visibility {
object
.key("VerticalOverflowVisibility")
.string(var_2195.as_str());
}
if let Some(var_2196) = &input.overflow_column_header_visibility {
object
.key("OverflowColumnHeaderVisibility")
.string(var_2196.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_pivot_table_conditional_formatting_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PivotTableConditionalFormattingOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2197) = &input.cell {
#[allow(unused_mut)]
let mut object_2198 = object.key("Cell").start_object();
crate::json_ser::serialize_structure_crate_model_pivot_table_cell_conditional_formatting(
&mut object_2198,
var_2197,
)?;
object_2198.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_bar_chart_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BarChartFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2199) = &input.bar_chart_aggregated_field_wells {
#[allow(unused_mut)]
let mut object_2200 = object.key("BarChartAggregatedFieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_bar_chart_aggregated_field_wells(
&mut object_2200,
var_2199,
)?;
object_2200.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_bar_chart_sort_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BarChartSortConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2201) = &input.category_sort {
let mut array_2202 = object.key("CategorySort").start_array();
for item_2203 in var_2201 {
{
#[allow(unused_mut)]
let mut object_2204 = array_2202.value().start_object();
crate::json_ser::serialize_structure_crate_model_field_sort_options(
&mut object_2204,
item_2203,
)?;
object_2204.finish();
}
}
array_2202.finish();
}
if let Some(var_2205) = &input.category_items_limit {
#[allow(unused_mut)]
let mut object_2206 = object.key("CategoryItemsLimit").start_object();
crate::json_ser::serialize_structure_crate_model_items_limit_configuration(
&mut object_2206,
var_2205,
)?;
object_2206.finish();
}
if let Some(var_2207) = &input.color_sort {
let mut array_2208 = object.key("ColorSort").start_array();
for item_2209 in var_2207 {
{
#[allow(unused_mut)]
let mut object_2210 = array_2208.value().start_object();
crate::json_ser::serialize_structure_crate_model_field_sort_options(
&mut object_2210,
item_2209,
)?;
object_2210.finish();
}
}
array_2208.finish();
}
if let Some(var_2211) = &input.color_items_limit {
#[allow(unused_mut)]
let mut object_2212 = object.key("ColorItemsLimit").start_object();
crate::json_ser::serialize_structure_crate_model_items_limit_configuration(
&mut object_2212,
var_2211,
)?;
object_2212.finish();
}
if let Some(var_2213) = &input.small_multiples_sort {
let mut array_2214 = object.key("SmallMultiplesSort").start_array();
for item_2215 in var_2213 {
{
#[allow(unused_mut)]
let mut object_2216 = array_2214.value().start_object();
crate::json_ser::serialize_structure_crate_model_field_sort_options(
&mut object_2216,
item_2215,
)?;
object_2216.finish();
}
}
array_2214.finish();
}
if let Some(var_2217) = &input.small_multiples_limit_configuration {
#[allow(unused_mut)]
let mut object_2218 = object
.key("SmallMultiplesLimitConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_items_limit_configuration(
&mut object_2218,
var_2217,
)?;
object_2218.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_visual_palette(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VisualPalette,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2219) = &input.chart_color {
object.key("ChartColor").string(var_2219.as_str());
}
if let Some(var_2220) = &input.color_map {
let mut array_2221 = object.key("ColorMap").start_array();
for item_2222 in var_2220 {
{
#[allow(unused_mut)]
let mut object_2223 = array_2221.value().start_object();
crate::json_ser::serialize_structure_crate_model_data_path_color(
&mut object_2223,
item_2222,
)?;
object_2223.finish();
}
}
array_2221.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_small_multiples_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SmallMultiplesOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2224) = &input.max_visible_rows {
object.key("MaxVisibleRows").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2224).into()),
);
}
if let Some(var_2225) = &input.max_visible_columns {
object.key("MaxVisibleColumns").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2225).into()),
);
}
if let Some(var_2226) = &input.panel_configuration {
#[allow(unused_mut)]
let mut object_2227 = object.key("PanelConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_panel_configuration(
&mut object_2227,
var_2226,
)?;
object_2227.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_axis_display_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AxisDisplayOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2228) = &input.tick_label_options {
#[allow(unused_mut)]
let mut object_2229 = object.key("TickLabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_axis_tick_label_options(
&mut object_2229,
var_2228,
)?;
object_2229.finish();
}
if let Some(var_2230) = &input.axis_line_visibility {
object.key("AxisLineVisibility").string(var_2230.as_str());
}
if let Some(var_2231) = &input.grid_line_visibility {
object.key("GridLineVisibility").string(var_2231.as_str());
}
if let Some(var_2232) = &input.data_options {
#[allow(unused_mut)]
let mut object_2233 = object.key("DataOptions").start_object();
crate::json_ser::serialize_structure_crate_model_axis_data_options(
&mut object_2233,
var_2232,
)?;
object_2233.finish();
}
if let Some(var_2234) = &input.scrollbar_options {
#[allow(unused_mut)]
let mut object_2235 = object.key("ScrollbarOptions").start_object();
crate::json_ser::serialize_structure_crate_model_scroll_bar_options(
&mut object_2235,
var_2234,
)?;
object_2235.finish();
}
if let Some(var_2236) = &input.axis_offset {
object.key("AxisOffset").string(var_2236.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_chart_axis_label_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ChartAxisLabelOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2237) = &input.visibility {
object.key("Visibility").string(var_2237.as_str());
}
if let Some(var_2238) = &input.sort_icon_visibility {
object.key("SortIconVisibility").string(var_2238.as_str());
}
if let Some(var_2239) = &input.axis_label_options {
let mut array_2240 = object.key("AxisLabelOptions").start_array();
for item_2241 in var_2239 {
{
#[allow(unused_mut)]
let mut object_2242 = array_2240.value().start_object();
crate::json_ser::serialize_structure_crate_model_axis_label_options(
&mut object_2242,
item_2241,
)?;
object_2242.finish();
}
}
array_2240.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_legend_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LegendOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2243) = &input.visibility {
object.key("Visibility").string(var_2243.as_str());
}
if let Some(var_2244) = &input.title {
#[allow(unused_mut)]
let mut object_2245 = object.key("Title").start_object();
crate::json_ser::serialize_structure_crate_model_label_options(&mut object_2245, var_2244)?;
object_2245.finish();
}
if let Some(var_2246) = &input.position {
object.key("Position").string(var_2246.as_str());
}
if let Some(var_2247) = &input.width {
object.key("Width").string(var_2247.as_str());
}
if let Some(var_2248) = &input.height {
object.key("Height").string(var_2248.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_data_label_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataLabelOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2249) = &input.visibility {
object.key("Visibility").string(var_2249.as_str());
}
if let Some(var_2250) = &input.category_label_visibility {
object
.key("CategoryLabelVisibility")
.string(var_2250.as_str());
}
if let Some(var_2251) = &input.measure_label_visibility {
object
.key("MeasureLabelVisibility")
.string(var_2251.as_str());
}
if let Some(var_2252) = &input.data_label_types {
let mut array_2253 = object.key("DataLabelTypes").start_array();
for item_2254 in var_2252 {
{
#[allow(unused_mut)]
let mut object_2255 = array_2253.value().start_object();
crate::json_ser::serialize_structure_crate_model_data_label_type(
&mut object_2255,
item_2254,
)?;
object_2255.finish();
}
}
array_2253.finish();
}
if let Some(var_2256) = &input.position {
object.key("Position").string(var_2256.as_str());
}
if let Some(var_2257) = &input.label_content {
object.key("LabelContent").string(var_2257.as_str());
}
if let Some(var_2258) = &input.label_font_configuration {
#[allow(unused_mut)]
let mut object_2259 = object.key("LabelFontConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_font_configuration(
&mut object_2259,
var_2258,
)?;
object_2259.finish();
}
if let Some(var_2260) = &input.label_color {
object.key("LabelColor").string(var_2260.as_str());
}
if let Some(var_2261) = &input.overlap {
object.key("Overlap").string(var_2261.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tooltip_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TooltipOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2262) = &input.tooltip_visibility {
object.key("TooltipVisibility").string(var_2262.as_str());
}
if let Some(var_2263) = &input.selected_tooltip_type {
object.key("SelectedTooltipType").string(var_2263.as_str());
}
if let Some(var_2264) = &input.field_based_tooltip {
#[allow(unused_mut)]
let mut object_2265 = object.key("FieldBasedTooltip").start_object();
crate::json_ser::serialize_structure_crate_model_field_based_tooltip(
&mut object_2265,
var_2264,
)?;
object_2265.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_reference_line(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReferenceLine,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2266) = &input.status {
object.key("Status").string(var_2266.as_str());
}
if let Some(var_2267) = &input.data_configuration {
#[allow(unused_mut)]
let mut object_2268 = object.key("DataConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_reference_line_data_configuration(
&mut object_2268,
var_2267,
)?;
object_2268.finish();
}
if let Some(var_2269) = &input.style_configuration {
#[allow(unused_mut)]
let mut object_2270 = object.key("StyleConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_reference_line_style_configuration(
&mut object_2270,
var_2269,
)?;
object_2270.finish();
}
if let Some(var_2271) = &input.label_configuration {
#[allow(unused_mut)]
let mut object_2272 = object.key("LabelConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_reference_line_label_configuration(
&mut object_2272,
var_2271,
)?;
object_2272.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_contribution_analysis_default(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ContributionAnalysisDefault,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2273) = &input.measure_field_id {
object.key("MeasureFieldId").string(var_2273.as_str());
}
if let Some(var_2274) = &input.contributor_dimensions {
let mut array_2275 = object.key("ContributorDimensions").start_array();
for item_2276 in var_2274 {
{
#[allow(unused_mut)]
let mut object_2277 = array_2275.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_2277,
item_2276,
)?;
object_2277.finish();
}
}
array_2275.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_explicit_hierarchy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExplicitHierarchy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2278) = &input.hierarchy_id {
object.key("HierarchyId").string(var_2278.as_str());
}
if let Some(var_2279) = &input.columns {
let mut array_2280 = object.key("Columns").start_array();
for item_2281 in var_2279 {
{
#[allow(unused_mut)]
let mut object_2282 = array_2280.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_2282,
item_2281,
)?;
object_2282.finish();
}
}
array_2280.finish();
}
if let Some(var_2283) = &input.drill_down_filters {
let mut array_2284 = object.key("DrillDownFilters").start_array();
for item_2285 in var_2283 {
{
#[allow(unused_mut)]
let mut object_2286 = array_2284.value().start_object();
crate::json_ser::serialize_structure_crate_model_drill_down_filter(
&mut object_2286,
item_2285,
)?;
object_2286.finish();
}
}
array_2284.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_date_time_hierarchy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DateTimeHierarchy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2287) = &input.hierarchy_id {
object.key("HierarchyId").string(var_2287.as_str());
}
if let Some(var_2288) = &input.drill_down_filters {
let mut array_2289 = object.key("DrillDownFilters").start_array();
for item_2290 in var_2288 {
{
#[allow(unused_mut)]
let mut object_2291 = array_2289.value().start_object();
crate::json_ser::serialize_structure_crate_model_drill_down_filter(
&mut object_2291,
item_2290,
)?;
object_2291.finish();
}
}
array_2289.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_predefined_hierarchy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PredefinedHierarchy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2292) = &input.hierarchy_id {
object.key("HierarchyId").string(var_2292.as_str());
}
if let Some(var_2293) = &input.columns {
let mut array_2294 = object.key("Columns").start_array();
for item_2295 in var_2293 {
{
#[allow(unused_mut)]
let mut object_2296 = array_2294.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_2296,
item_2295,
)?;
object_2296.finish();
}
}
array_2294.finish();
}
if let Some(var_2297) = &input.drill_down_filters {
let mut array_2298 = object.key("DrillDownFilters").start_array();
for item_2299 in var_2297 {
{
#[allow(unused_mut)]
let mut object_2300 = array_2298.value().start_object();
crate::json_ser::serialize_structure_crate_model_drill_down_filter(
&mut object_2300,
item_2299,
)?;
object_2300.finish();
}
}
array_2298.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_kpi_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KpiFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2301) = &input.values {
let mut array_2302 = object.key("Values").start_array();
for item_2303 in var_2301 {
{
#[allow(unused_mut)]
let mut object_2304 = array_2302.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_2304,
item_2303,
)?;
object_2304.finish();
}
}
array_2302.finish();
}
if let Some(var_2305) = &input.target_values {
let mut array_2306 = object.key("TargetValues").start_array();
for item_2307 in var_2305 {
{
#[allow(unused_mut)]
let mut object_2308 = array_2306.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_2308,
item_2307,
)?;
object_2308.finish();
}
}
array_2306.finish();
}
if let Some(var_2309) = &input.trend_groups {
let mut array_2310 = object.key("TrendGroups").start_array();
for item_2311 in var_2309 {
{
#[allow(unused_mut)]
let mut object_2312 = array_2310.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_2312,
item_2311,
)?;
object_2312.finish();
}
}
array_2310.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_kpi_sort_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KpiSortConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2313) = &input.trend_group_sort {
let mut array_2314 = object.key("TrendGroupSort").start_array();
for item_2315 in var_2313 {
{
#[allow(unused_mut)]
let mut object_2316 = array_2314.value().start_object();
crate::json_ser::serialize_structure_crate_model_field_sort_options(
&mut object_2316,
item_2315,
)?;
object_2316.finish();
}
}
array_2314.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_kpi_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KpiOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2317) = &input.progress_bar {
#[allow(unused_mut)]
let mut object_2318 = object.key("ProgressBar").start_object();
crate::json_ser::serialize_structure_crate_model_progress_bar_options(
&mut object_2318,
var_2317,
)?;
object_2318.finish();
}
if let Some(var_2319) = &input.trend_arrows {
#[allow(unused_mut)]
let mut object_2320 = object.key("TrendArrows").start_object();
crate::json_ser::serialize_structure_crate_model_trend_arrow_options(
&mut object_2320,
var_2319,
)?;
object_2320.finish();
}
if let Some(var_2321) = &input.secondary_value {
#[allow(unused_mut)]
let mut object_2322 = object.key("SecondaryValue").start_object();
crate::json_ser::serialize_structure_crate_model_secondary_value_options(
&mut object_2322,
var_2321,
)?;
object_2322.finish();
}
if let Some(var_2323) = &input.comparison {
#[allow(unused_mut)]
let mut object_2324 = object.key("Comparison").start_object();
crate::json_ser::serialize_structure_crate_model_comparison_configuration(
&mut object_2324,
var_2323,
)?;
object_2324.finish();
}
if let Some(var_2325) = &input.primary_value_display_type {
object
.key("PrimaryValueDisplayType")
.string(var_2325.as_str());
}
if let Some(var_2326) = &input.primary_value_font_configuration {
#[allow(unused_mut)]
let mut object_2327 = object.key("PrimaryValueFontConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_font_configuration(
&mut object_2327,
var_2326,
)?;
object_2327.finish();
}
if let Some(var_2328) = &input.secondary_value_font_configuration {
#[allow(unused_mut)]
let mut object_2329 = object.key("SecondaryValueFontConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_font_configuration(
&mut object_2329,
var_2328,
)?;
object_2329.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_kpi_conditional_formatting_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KpiConditionalFormattingOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2330) = &input.primary_value {
#[allow(unused_mut)]
let mut object_2331 = object.key("PrimaryValue").start_object();
crate::json_ser::serialize_structure_crate_model_kpi_primary_value_conditional_formatting(
&mut object_2331,
var_2330,
)?;
object_2331.finish();
}
if let Some(var_2332) = &input.progress_bar {
#[allow(unused_mut)]
let mut object_2333 = object.key("ProgressBar").start_object();
crate::json_ser::serialize_structure_crate_model_kpi_progress_bar_conditional_formatting(
&mut object_2333,
var_2332,
)?;
object_2333.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pie_chart_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PieChartFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2334) = &input.pie_chart_aggregated_field_wells {
#[allow(unused_mut)]
let mut object_2335 = object.key("PieChartAggregatedFieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_pie_chart_aggregated_field_wells(
&mut object_2335,
var_2334,
)?;
object_2335.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pie_chart_sort_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PieChartSortConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2336) = &input.category_sort {
let mut array_2337 = object.key("CategorySort").start_array();
for item_2338 in var_2336 {
{
#[allow(unused_mut)]
let mut object_2339 = array_2337.value().start_object();
crate::json_ser::serialize_structure_crate_model_field_sort_options(
&mut object_2339,
item_2338,
)?;
object_2339.finish();
}
}
array_2337.finish();
}
if let Some(var_2340) = &input.category_items_limit {
#[allow(unused_mut)]
let mut object_2341 = object.key("CategoryItemsLimit").start_object();
crate::json_ser::serialize_structure_crate_model_items_limit_configuration(
&mut object_2341,
var_2340,
)?;
object_2341.finish();
}
if let Some(var_2342) = &input.small_multiples_sort {
let mut array_2343 = object.key("SmallMultiplesSort").start_array();
for item_2344 in var_2342 {
{
#[allow(unused_mut)]
let mut object_2345 = array_2343.value().start_object();
crate::json_ser::serialize_structure_crate_model_field_sort_options(
&mut object_2345,
item_2344,
)?;
object_2345.finish();
}
}
array_2343.finish();
}
if let Some(var_2346) = &input.small_multiples_limit_configuration {
#[allow(unused_mut)]
let mut object_2347 = object
.key("SmallMultiplesLimitConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_items_limit_configuration(
&mut object_2347,
var_2346,
)?;
object_2347.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_donut_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DonutOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2348) = &input.arc_options {
#[allow(unused_mut)]
let mut object_2349 = object.key("ArcOptions").start_object();
crate::json_ser::serialize_structure_crate_model_arc_options(&mut object_2349, var_2348)?;
object_2349.finish();
}
if let Some(var_2350) = &input.donut_center_options {
#[allow(unused_mut)]
let mut object_2351 = object.key("DonutCenterOptions").start_object();
crate::json_ser::serialize_structure_crate_model_donut_center_options(
&mut object_2351,
var_2350,
)?;
object_2351.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_gauge_chart_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GaugeChartFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2352) = &input.values {
let mut array_2353 = object.key("Values").start_array();
for item_2354 in var_2352 {
{
#[allow(unused_mut)]
let mut object_2355 = array_2353.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_2355,
item_2354,
)?;
object_2355.finish();
}
}
array_2353.finish();
}
if let Some(var_2356) = &input.target_values {
let mut array_2357 = object.key("TargetValues").start_array();
for item_2358 in var_2356 {
{
#[allow(unused_mut)]
let mut object_2359 = array_2357.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_2359,
item_2358,
)?;
object_2359.finish();
}
}
array_2357.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_gauge_chart_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GaugeChartOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2360) = &input.primary_value_display_type {
object
.key("PrimaryValueDisplayType")
.string(var_2360.as_str());
}
if let Some(var_2361) = &input.comparison {
#[allow(unused_mut)]
let mut object_2362 = object.key("Comparison").start_object();
crate::json_ser::serialize_structure_crate_model_comparison_configuration(
&mut object_2362,
var_2361,
)?;
object_2362.finish();
}
if let Some(var_2363) = &input.arc_axis {
#[allow(unused_mut)]
let mut object_2364 = object.key("ArcAxis").start_object();
crate::json_ser::serialize_structure_crate_model_arc_axis_configuration(
&mut object_2364,
var_2363,
)?;
object_2364.finish();
}
if let Some(var_2365) = &input.arc {
#[allow(unused_mut)]
let mut object_2366 = object.key("Arc").start_object();
crate::json_ser::serialize_structure_crate_model_arc_configuration(
&mut object_2366,
var_2365,
)?;
object_2366.finish();
}
if let Some(var_2367) = &input.primary_value_font_configuration {
#[allow(unused_mut)]
let mut object_2368 = object.key("PrimaryValueFontConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_font_configuration(
&mut object_2368,
var_2367,
)?;
object_2368.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_gauge_chart_conditional_formatting_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GaugeChartConditionalFormattingOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2369) = &input.primary_value {
#[allow(unused_mut)]
let mut object_2370 = object.key("PrimaryValue").start_object();
crate::json_ser::serialize_structure_crate_model_gauge_chart_primary_value_conditional_formatting(&mut object_2370, var_2369)?;
object_2370.finish();
}
if let Some(var_2371) = &input.arc {
#[allow(unused_mut)]
let mut object_2372 = object.key("Arc").start_object();
crate::json_ser::serialize_structure_crate_model_gauge_chart_arc_conditional_formatting(
&mut object_2372,
var_2371,
)?;
object_2372.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_line_chart_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LineChartFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2373) = &input.line_chart_aggregated_field_wells {
#[allow(unused_mut)]
let mut object_2374 = object.key("LineChartAggregatedFieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_line_chart_aggregated_field_wells(
&mut object_2374,
var_2373,
)?;
object_2374.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_line_chart_sort_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LineChartSortConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2375) = &input.category_sort {
let mut array_2376 = object.key("CategorySort").start_array();
for item_2377 in var_2375 {
{
#[allow(unused_mut)]
let mut object_2378 = array_2376.value().start_object();
crate::json_ser::serialize_structure_crate_model_field_sort_options(
&mut object_2378,
item_2377,
)?;
object_2378.finish();
}
}
array_2376.finish();
}
if let Some(var_2379) = &input.category_items_limit_configuration {
#[allow(unused_mut)]
let mut object_2380 = object.key("CategoryItemsLimitConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_items_limit_configuration(
&mut object_2380,
var_2379,
)?;
object_2380.finish();
}
if let Some(var_2381) = &input.color_items_limit_configuration {
#[allow(unused_mut)]
let mut object_2382 = object.key("ColorItemsLimitConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_items_limit_configuration(
&mut object_2382,
var_2381,
)?;
object_2382.finish();
}
if let Some(var_2383) = &input.small_multiples_sort {
let mut array_2384 = object.key("SmallMultiplesSort").start_array();
for item_2385 in var_2383 {
{
#[allow(unused_mut)]
let mut object_2386 = array_2384.value().start_object();
crate::json_ser::serialize_structure_crate_model_field_sort_options(
&mut object_2386,
item_2385,
)?;
object_2386.finish();
}
}
array_2384.finish();
}
if let Some(var_2387) = &input.small_multiples_limit_configuration {
#[allow(unused_mut)]
let mut object_2388 = object
.key("SmallMultiplesLimitConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_items_limit_configuration(
&mut object_2388,
var_2387,
)?;
object_2388.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_forecast_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ForecastConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2389) = &input.forecast_properties {
#[allow(unused_mut)]
let mut object_2390 = object.key("ForecastProperties").start_object();
crate::json_ser::serialize_structure_crate_model_time_based_forecast_properties(
&mut object_2390,
var_2389,
)?;
object_2390.finish();
}
if let Some(var_2391) = &input.scenario {
#[allow(unused_mut)]
let mut object_2392 = object.key("Scenario").start_object();
crate::json_ser::serialize_structure_crate_model_forecast_scenario(
&mut object_2392,
var_2391,
)?;
object_2392.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_line_series_axis_display_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LineSeriesAxisDisplayOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2393) = &input.axis_options {
#[allow(unused_mut)]
let mut object_2394 = object.key("AxisOptions").start_object();
crate::json_ser::serialize_structure_crate_model_axis_display_options(
&mut object_2394,
var_2393,
)?;
object_2394.finish();
}
if let Some(var_2395) = &input.missing_data_configurations {
let mut array_2396 = object.key("MissingDataConfigurations").start_array();
for item_2397 in var_2395 {
{
#[allow(unused_mut)]
let mut object_2398 = array_2396.value().start_object();
crate::json_ser::serialize_structure_crate_model_missing_data_configuration(
&mut object_2398,
item_2397,
)?;
object_2398.finish();
}
}
array_2396.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_line_chart_default_series_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LineChartDefaultSeriesSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2399) = &input.axis_binding {
object.key("AxisBinding").string(var_2399.as_str());
}
if let Some(var_2400) = &input.line_style_settings {
#[allow(unused_mut)]
let mut object_2401 = object.key("LineStyleSettings").start_object();
crate::json_ser::serialize_structure_crate_model_line_chart_line_style_settings(
&mut object_2401,
var_2400,
)?;
object_2401.finish();
}
if let Some(var_2402) = &input.marker_style_settings {
#[allow(unused_mut)]
let mut object_2403 = object.key("MarkerStyleSettings").start_object();
crate::json_ser::serialize_structure_crate_model_line_chart_marker_style_settings(
&mut object_2403,
var_2402,
)?;
object_2403.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_series_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SeriesItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2404) = &input.field_series_item {
#[allow(unused_mut)]
let mut object_2405 = object.key("FieldSeriesItem").start_object();
crate::json_ser::serialize_structure_crate_model_field_series_item(
&mut object_2405,
var_2404,
)?;
object_2405.finish();
}
if let Some(var_2406) = &input.data_field_series_item {
#[allow(unused_mut)]
let mut object_2407 = object.key("DataFieldSeriesItem").start_object();
crate::json_ser::serialize_structure_crate_model_data_field_series_item(
&mut object_2407,
var_2406,
)?;
object_2407.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_heat_map_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HeatMapFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2408) = &input.heat_map_aggregated_field_wells {
#[allow(unused_mut)]
let mut object_2409 = object.key("HeatMapAggregatedFieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_heat_map_aggregated_field_wells(
&mut object_2409,
var_2408,
)?;
object_2409.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_heat_map_sort_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HeatMapSortConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2410) = &input.heat_map_row_sort {
let mut array_2411 = object.key("HeatMapRowSort").start_array();
for item_2412 in var_2410 {
{
#[allow(unused_mut)]
let mut object_2413 = array_2411.value().start_object();
crate::json_ser::serialize_structure_crate_model_field_sort_options(
&mut object_2413,
item_2412,
)?;
object_2413.finish();
}
}
array_2411.finish();
}
if let Some(var_2414) = &input.heat_map_column_sort {
let mut array_2415 = object.key("HeatMapColumnSort").start_array();
for item_2416 in var_2414 {
{
#[allow(unused_mut)]
let mut object_2417 = array_2415.value().start_object();
crate::json_ser::serialize_structure_crate_model_field_sort_options(
&mut object_2417,
item_2416,
)?;
object_2417.finish();
}
}
array_2415.finish();
}
if let Some(var_2418) = &input.heat_map_row_items_limit_configuration {
#[allow(unused_mut)]
let mut object_2419 = object
.key("HeatMapRowItemsLimitConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_items_limit_configuration(
&mut object_2419,
var_2418,
)?;
object_2419.finish();
}
if let Some(var_2420) = &input.heat_map_column_items_limit_configuration {
#[allow(unused_mut)]
let mut object_2421 = object
.key("HeatMapColumnItemsLimitConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_items_limit_configuration(
&mut object_2421,
var_2420,
)?;
object_2421.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_color_scale(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ColorScale,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2422) = &input.colors {
let mut array_2423 = object.key("Colors").start_array();
for item_2424 in var_2422 {
{
#[allow(unused_mut)]
let mut object_2425 = array_2423.value().start_object();
crate::json_ser::serialize_structure_crate_model_data_color(
&mut object_2425,
item_2424,
)?;
object_2425.finish();
}
}
array_2423.finish();
}
if let Some(var_2426) = &input.color_fill_type {
object.key("ColorFillType").string(var_2426.as_str());
}
if let Some(var_2427) = &input.null_value_color {
#[allow(unused_mut)]
let mut object_2428 = object.key("NullValueColor").start_object();
crate::json_ser::serialize_structure_crate_model_data_color(&mut object_2428, var_2427)?;
object_2428.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tree_map_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TreeMapFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2429) = &input.tree_map_aggregated_field_wells {
#[allow(unused_mut)]
let mut object_2430 = object.key("TreeMapAggregatedFieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_tree_map_aggregated_field_wells(
&mut object_2430,
var_2429,
)?;
object_2430.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tree_map_sort_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TreeMapSortConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2431) = &input.tree_map_sort {
let mut array_2432 = object.key("TreeMapSort").start_array();
for item_2433 in var_2431 {
{
#[allow(unused_mut)]
let mut object_2434 = array_2432.value().start_object();
crate::json_ser::serialize_structure_crate_model_field_sort_options(
&mut object_2434,
item_2433,
)?;
object_2434.finish();
}
}
array_2432.finish();
}
if let Some(var_2435) = &input.tree_map_group_items_limit_configuration {
#[allow(unused_mut)]
let mut object_2436 = object
.key("TreeMapGroupItemsLimitConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_items_limit_configuration(
&mut object_2436,
var_2435,
)?;
object_2436.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_geospatial_map_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GeospatialMapFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2437) = &input.geospatial_map_aggregated_field_wells {
#[allow(unused_mut)]
let mut object_2438 = object
.key("GeospatialMapAggregatedFieldWells")
.start_object();
crate::json_ser::serialize_structure_crate_model_geospatial_map_aggregated_field_wells(
&mut object_2438,
var_2437,
)?;
object_2438.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_geospatial_window_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GeospatialWindowOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2439) = &input.bounds {
#[allow(unused_mut)]
let mut object_2440 = object.key("Bounds").start_object();
crate::json_ser::serialize_structure_crate_model_geospatial_coordinate_bounds(
&mut object_2440,
var_2439,
)?;
object_2440.finish();
}
if let Some(var_2441) = &input.map_zoom_mode {
object.key("MapZoomMode").string(var_2441.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_geospatial_map_style_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GeospatialMapStyleOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2442) = &input.base_map_style {
object.key("BaseMapStyle").string(var_2442.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_geospatial_point_style_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GeospatialPointStyleOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2443) = &input.selected_point_style {
object.key("SelectedPointStyle").string(var_2443.as_str());
}
if let Some(var_2444) = &input.cluster_marker_configuration {
#[allow(unused_mut)]
let mut object_2445 = object.key("ClusterMarkerConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_cluster_marker_configuration(
&mut object_2445,
var_2444,
)?;
object_2445.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filled_map_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilledMapFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2446) = &input.filled_map_aggregated_field_wells {
#[allow(unused_mut)]
let mut object_2447 = object.key("FilledMapAggregatedFieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_filled_map_aggregated_field_wells(
&mut object_2447,
var_2446,
)?;
object_2447.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filled_map_sort_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilledMapSortConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2448) = &input.category_sort {
let mut array_2449 = object.key("CategorySort").start_array();
for item_2450 in var_2448 {
{
#[allow(unused_mut)]
let mut object_2451 = array_2449.value().start_object();
crate::json_ser::serialize_structure_crate_model_field_sort_options(
&mut object_2451,
item_2450,
)?;
object_2451.finish();
}
}
array_2449.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filled_map_conditional_formatting_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilledMapConditionalFormattingOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2452) = &input.shape {
#[allow(unused_mut)]
let mut object_2453 = object.key("Shape").start_object();
crate::json_ser::serialize_structure_crate_model_filled_map_shape_conditional_formatting(
&mut object_2453,
var_2452,
)?;
object_2453.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_funnel_chart_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FunnelChartFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2454) = &input.funnel_chart_aggregated_field_wells {
#[allow(unused_mut)]
let mut object_2455 = object.key("FunnelChartAggregatedFieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_funnel_chart_aggregated_field_wells(
&mut object_2455,
var_2454,
)?;
object_2455.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_funnel_chart_sort_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FunnelChartSortConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2456) = &input.category_sort {
let mut array_2457 = object.key("CategorySort").start_array();
for item_2458 in var_2456 {
{
#[allow(unused_mut)]
let mut object_2459 = array_2457.value().start_object();
crate::json_ser::serialize_structure_crate_model_field_sort_options(
&mut object_2459,
item_2458,
)?;
object_2459.finish();
}
}
array_2457.finish();
}
if let Some(var_2460) = &input.category_items_limit {
#[allow(unused_mut)]
let mut object_2461 = object.key("CategoryItemsLimit").start_object();
crate::json_ser::serialize_structure_crate_model_items_limit_configuration(
&mut object_2461,
var_2460,
)?;
object_2461.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_funnel_chart_data_label_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FunnelChartDataLabelOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2462) = &input.visibility {
object.key("Visibility").string(var_2462.as_str());
}
if let Some(var_2463) = &input.category_label_visibility {
object
.key("CategoryLabelVisibility")
.string(var_2463.as_str());
}
if let Some(var_2464) = &input.measure_label_visibility {
object
.key("MeasureLabelVisibility")
.string(var_2464.as_str());
}
if let Some(var_2465) = &input.position {
object.key("Position").string(var_2465.as_str());
}
if let Some(var_2466) = &input.label_font_configuration {
#[allow(unused_mut)]
let mut object_2467 = object.key("LabelFontConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_font_configuration(
&mut object_2467,
var_2466,
)?;
object_2467.finish();
}
if let Some(var_2468) = &input.label_color {
object.key("LabelColor").string(var_2468.as_str());
}
if let Some(var_2469) = &input.measure_data_label_style {
object
.key("MeasureDataLabelStyle")
.string(var_2469.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_scatter_plot_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ScatterPlotFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2470) = &input.scatter_plot_categorically_aggregated_field_wells {
#[allow(unused_mut)]
let mut object_2471 = object
.key("ScatterPlotCategoricallyAggregatedFieldWells")
.start_object();
crate::json_ser::serialize_structure_crate_model_scatter_plot_categorically_aggregated_field_wells(&mut object_2471, var_2470)?;
object_2471.finish();
}
if let Some(var_2472) = &input.scatter_plot_unaggregated_field_wells {
#[allow(unused_mut)]
let mut object_2473 = object
.key("ScatterPlotUnaggregatedFieldWells")
.start_object();
crate::json_ser::serialize_structure_crate_model_scatter_plot_unaggregated_field_wells(
&mut object_2473,
var_2472,
)?;
object_2473.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_combo_chart_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComboChartFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2474) = &input.combo_chart_aggregated_field_wells {
#[allow(unused_mut)]
let mut object_2475 = object.key("ComboChartAggregatedFieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_combo_chart_aggregated_field_wells(
&mut object_2475,
var_2474,
)?;
object_2475.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_combo_chart_sort_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComboChartSortConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2476) = &input.category_sort {
let mut array_2477 = object.key("CategorySort").start_array();
for item_2478 in var_2476 {
{
#[allow(unused_mut)]
let mut object_2479 = array_2477.value().start_object();
crate::json_ser::serialize_structure_crate_model_field_sort_options(
&mut object_2479,
item_2478,
)?;
object_2479.finish();
}
}
array_2477.finish();
}
if let Some(var_2480) = &input.category_items_limit {
#[allow(unused_mut)]
let mut object_2481 = object.key("CategoryItemsLimit").start_object();
crate::json_ser::serialize_structure_crate_model_items_limit_configuration(
&mut object_2481,
var_2480,
)?;
object_2481.finish();
}
if let Some(var_2482) = &input.color_sort {
let mut array_2483 = object.key("ColorSort").start_array();
for item_2484 in var_2482 {
{
#[allow(unused_mut)]
let mut object_2485 = array_2483.value().start_object();
crate::json_ser::serialize_structure_crate_model_field_sort_options(
&mut object_2485,
item_2484,
)?;
object_2485.finish();
}
}
array_2483.finish();
}
if let Some(var_2486) = &input.color_items_limit {
#[allow(unused_mut)]
let mut object_2487 = object.key("ColorItemsLimit").start_object();
crate::json_ser::serialize_structure_crate_model_items_limit_configuration(
&mut object_2487,
var_2486,
)?;
object_2487.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_box_plot_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BoxPlotFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2488) = &input.box_plot_aggregated_field_wells {
#[allow(unused_mut)]
let mut object_2489 = object.key("BoxPlotAggregatedFieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_box_plot_aggregated_field_wells(
&mut object_2489,
var_2488,
)?;
object_2489.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_box_plot_sort_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BoxPlotSortConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2490) = &input.category_sort {
let mut array_2491 = object.key("CategorySort").start_array();
for item_2492 in var_2490 {
{
#[allow(unused_mut)]
let mut object_2493 = array_2491.value().start_object();
crate::json_ser::serialize_structure_crate_model_field_sort_options(
&mut object_2493,
item_2492,
)?;
object_2493.finish();
}
}
array_2491.finish();
}
if let Some(var_2494) = &input.pagination_configuration {
#[allow(unused_mut)]
let mut object_2495 = object.key("PaginationConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_pagination_configuration(
&mut object_2495,
var_2494,
)?;
object_2495.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_box_plot_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BoxPlotOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2496) = &input.style_options {
#[allow(unused_mut)]
let mut object_2497 = object.key("StyleOptions").start_object();
crate::json_ser::serialize_structure_crate_model_box_plot_style_options(
&mut object_2497,
var_2496,
)?;
object_2497.finish();
}
if let Some(var_2498) = &input.outlier_visibility {
object.key("OutlierVisibility").string(var_2498.as_str());
}
if let Some(var_2499) = &input.all_data_points_visibility {
object
.key("AllDataPointsVisibility")
.string(var_2499.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_waterfall_chart_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WaterfallChartFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2500) = &input.waterfall_chart_aggregated_field_wells {
#[allow(unused_mut)]
let mut object_2501 = object
.key("WaterfallChartAggregatedFieldWells")
.start_object();
crate::json_ser::serialize_structure_crate_model_waterfall_chart_aggregated_field_wells(
&mut object_2501,
var_2500,
)?;
object_2501.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_waterfall_chart_sort_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WaterfallChartSortConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2502) = &input.category_sort {
let mut array_2503 = object.key("CategorySort").start_array();
for item_2504 in var_2502 {
{
#[allow(unused_mut)]
let mut object_2505 = array_2503.value().start_object();
crate::json_ser::serialize_structure_crate_model_field_sort_options(
&mut object_2505,
item_2504,
)?;
object_2505.finish();
}
}
array_2503.finish();
}
if let Some(var_2506) = &input.breakdown_items_limit {
#[allow(unused_mut)]
let mut object_2507 = object.key("BreakdownItemsLimit").start_object();
crate::json_ser::serialize_structure_crate_model_items_limit_configuration(
&mut object_2507,
var_2506,
)?;
object_2507.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_waterfall_chart_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WaterfallChartOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2508) = &input.total_bar_label {
object.key("TotalBarLabel").string(var_2508.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_histogram_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HistogramFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2509) = &input.histogram_aggregated_field_wells {
#[allow(unused_mut)]
let mut object_2510 = object.key("HistogramAggregatedFieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_histogram_aggregated_field_wells(
&mut object_2510,
var_2509,
)?;
object_2510.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_histogram_bin_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HistogramBinOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2511) = &input.selected_bin_type {
object.key("SelectedBinType").string(var_2511.as_str());
}
if let Some(var_2512) = &input.bin_count {
#[allow(unused_mut)]
let mut object_2513 = object.key("BinCount").start_object();
crate::json_ser::serialize_structure_crate_model_bin_count_options(
&mut object_2513,
var_2512,
)?;
object_2513.finish();
}
if let Some(var_2514) = &input.bin_width {
#[allow(unused_mut)]
let mut object_2515 = object.key("BinWidth").start_object();
crate::json_ser::serialize_structure_crate_model_bin_width_options(
&mut object_2515,
var_2514,
)?;
object_2515.finish();
}
if let Some(var_2516) = &input.start_value {
object.key("StartValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_2516).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_word_cloud_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WordCloudFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2517) = &input.word_cloud_aggregated_field_wells {
#[allow(unused_mut)]
let mut object_2518 = object.key("WordCloudAggregatedFieldWells").start_object();
crate::json_ser::serialize_structure_crate_model_word_cloud_aggregated_field_wells(
&mut object_2518,
var_2517,
)?;
object_2518.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_word_cloud_sort_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WordCloudSortConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2519) = &input.category_items_limit {
#[allow(unused_mut)]
let mut object_2520 = object.key("CategoryItemsLimit").start_object();
crate::json_ser::serialize_structure_crate_model_items_limit_configuration(
&mut object_2520,
var_2519,
)?;
object_2520.finish();
}
if let Some(var_2521) = &input.category_sort {
let mut array_2522 = object.key("CategorySort").start_array();
for item_2523 in var_2521 {
{
#[allow(unused_mut)]
let mut object_2524 = array_2522.value().start_object();
crate::json_ser::serialize_structure_crate_model_field_sort_options(
&mut object_2524,
item_2523,
)?;
object_2524.finish();
}
}
array_2522.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_word_cloud_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WordCloudOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2525) = &input.word_orientation {
object.key("WordOrientation").string(var_2525.as_str());
}
if let Some(var_2526) = &input.word_scaling {
object.key("WordScaling").string(var_2526.as_str());
}
if let Some(var_2527) = &input.cloud_layout {
object.key("CloudLayout").string(var_2527.as_str());
}
if let Some(var_2528) = &input.word_casing {
object.key("WordCasing").string(var_2528.as_str());
}
if let Some(var_2529) = &input.word_padding {
object.key("WordPadding").string(var_2529.as_str());
}
if let Some(var_2530) = &input.maximum_string_length {
object.key("MaximumStringLength").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2530).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_computation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Computation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2531) = &input.top_bottom_ranked {
#[allow(unused_mut)]
let mut object_2532 = object.key("TopBottomRanked").start_object();
crate::json_ser::serialize_structure_crate_model_top_bottom_ranked_computation(
&mut object_2532,
var_2531,
)?;
object_2532.finish();
}
if let Some(var_2533) = &input.top_bottom_movers {
#[allow(unused_mut)]
let mut object_2534 = object.key("TopBottomMovers").start_object();
crate::json_ser::serialize_structure_crate_model_top_bottom_movers_computation(
&mut object_2534,
var_2533,
)?;
object_2534.finish();
}
if let Some(var_2535) = &input.total_aggregation {
#[allow(unused_mut)]
let mut object_2536 = object.key("TotalAggregation").start_object();
crate::json_ser::serialize_structure_crate_model_total_aggregation_computation(
&mut object_2536,
var_2535,
)?;
object_2536.finish();
}
if let Some(var_2537) = &input.maximum_minimum {
#[allow(unused_mut)]
let mut object_2538 = object.key("MaximumMinimum").start_object();
crate::json_ser::serialize_structure_crate_model_maximum_minimum_computation(
&mut object_2538,
var_2537,
)?;
object_2538.finish();
}
if let Some(var_2539) = &input.metric_comparison {
#[allow(unused_mut)]
let mut object_2540 = object.key("MetricComparison").start_object();
crate::json_ser::serialize_structure_crate_model_metric_comparison_computation(
&mut object_2540,
var_2539,
)?;
object_2540.finish();
}
if let Some(var_2541) = &input.period_over_period {
#[allow(unused_mut)]
let mut object_2542 = object.key("PeriodOverPeriod").start_object();
crate::json_ser::serialize_structure_crate_model_period_over_period_computation(
&mut object_2542,
var_2541,
)?;
object_2542.finish();
}
if let Some(var_2543) = &input.period_to_date {
#[allow(unused_mut)]
let mut object_2544 = object.key("PeriodToDate").start_object();
crate::json_ser::serialize_structure_crate_model_period_to_date_computation(
&mut object_2544,
var_2543,
)?;
object_2544.finish();
}
if let Some(var_2545) = &input.growth_rate {
#[allow(unused_mut)]
let mut object_2546 = object.key("GrowthRate").start_object();
crate::json_ser::serialize_structure_crate_model_growth_rate_computation(
&mut object_2546,
var_2545,
)?;
object_2546.finish();
}
if let Some(var_2547) = &input.unique_values {
#[allow(unused_mut)]
let mut object_2548 = object.key("UniqueValues").start_object();
crate::json_ser::serialize_structure_crate_model_unique_values_computation(
&mut object_2548,
var_2547,
)?;
object_2548.finish();
}
if let Some(var_2549) = &input.forecast {
#[allow(unused_mut)]
let mut object_2550 = object.key("Forecast").start_object();
crate::json_ser::serialize_structure_crate_model_forecast_computation(
&mut object_2550,
var_2549,
)?;
object_2550.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_narrative_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomNarrativeOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2551) = &input.narrative {
object.key("Narrative").string(var_2551.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sankey_diagram_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SankeyDiagramFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2552) = &input.sankey_diagram_aggregated_field_wells {
#[allow(unused_mut)]
let mut object_2553 = object
.key("SankeyDiagramAggregatedFieldWells")
.start_object();
crate::json_ser::serialize_structure_crate_model_sankey_diagram_aggregated_field_wells(
&mut object_2553,
var_2552,
)?;
object_2553.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sankey_diagram_sort_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SankeyDiagramSortConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2554) = &input.weight_sort {
let mut array_2555 = object.key("WeightSort").start_array();
for item_2556 in var_2554 {
{
#[allow(unused_mut)]
let mut object_2557 = array_2555.value().start_object();
crate::json_ser::serialize_structure_crate_model_field_sort_options(
&mut object_2557,
item_2556,
)?;
object_2557.finish();
}
}
array_2555.finish();
}
if let Some(var_2558) = &input.source_items_limit {
#[allow(unused_mut)]
let mut object_2559 = object.key("SourceItemsLimit").start_object();
crate::json_ser::serialize_structure_crate_model_items_limit_configuration(
&mut object_2559,
var_2558,
)?;
object_2559.finish();
}
if let Some(var_2560) = &input.destination_items_limit {
#[allow(unused_mut)]
let mut object_2561 = object.key("DestinationItemsLimit").start_object();
crate::json_ser::serialize_structure_crate_model_items_limit_configuration(
&mut object_2561,
var_2560,
)?;
object_2561.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_grid_layout_element(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GridLayoutElement,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2562) = &input.element_id {
object.key("ElementId").string(var_2562.as_str());
}
if let Some(var_2563) = &input.element_type {
object.key("ElementType").string(var_2563.as_str());
}
if let Some(var_2564) = &input.column_index {
object.key("ColumnIndex").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2564).into()),
);
}
if let Some(var_2565) = &input.column_span {
object.key("ColumnSpan").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2565).into()),
);
}
if let Some(var_2566) = &input.row_index {
object.key("RowIndex").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2566).into()),
);
}
if let Some(var_2567) = &input.row_span {
object.key("RowSpan").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2567).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_grid_layout_canvas_size_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GridLayoutCanvasSizeOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2568) = &input.screen_canvas_size_options {
#[allow(unused_mut)]
let mut object_2569 = object.key("ScreenCanvasSizeOptions").start_object();
crate::json_ser::serialize_structure_crate_model_grid_layout_screen_canvas_size_options(
&mut object_2569,
var_2568,
)?;
object_2569.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_free_form_layout_element(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FreeFormLayoutElement,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2570) = &input.element_id {
object.key("ElementId").string(var_2570.as_str());
}
if let Some(var_2571) = &input.element_type {
object.key("ElementType").string(var_2571.as_str());
}
if let Some(var_2572) = &input.x_axis_location {
object.key("XAxisLocation").string(var_2572.as_str());
}
if let Some(var_2573) = &input.y_axis_location {
object.key("YAxisLocation").string(var_2573.as_str());
}
if let Some(var_2574) = &input.width {
object.key("Width").string(var_2574.as_str());
}
if let Some(var_2575) = &input.height {
object.key("Height").string(var_2575.as_str());
}
if let Some(var_2576) = &input.visibility {
object.key("Visibility").string(var_2576.as_str());
}
if let Some(var_2577) = &input.rendering_rules {
let mut array_2578 = object.key("RenderingRules").start_array();
for item_2579 in var_2577 {
{
#[allow(unused_mut)]
let mut object_2580 = array_2578.value().start_object();
crate::json_ser::serialize_structure_crate_model_sheet_element_rendering_rule(
&mut object_2580,
item_2579,
)?;
object_2580.finish();
}
}
array_2578.finish();
}
if let Some(var_2581) = &input.border_style {
#[allow(unused_mut)]
let mut object_2582 = object.key("BorderStyle").start_object();
crate::json_ser::serialize_structure_crate_model_free_form_layout_element_border_style(
&mut object_2582,
var_2581,
)?;
object_2582.finish();
}
if let Some(var_2583) = &input.selected_border_style {
#[allow(unused_mut)]
let mut object_2584 = object.key("SelectedBorderStyle").start_object();
crate::json_ser::serialize_structure_crate_model_free_form_layout_element_border_style(
&mut object_2584,
var_2583,
)?;
object_2584.finish();
}
if let Some(var_2585) = &input.background_style {
#[allow(unused_mut)]
let mut object_2586 = object.key("BackgroundStyle").start_object();
crate::json_ser::serialize_structure_crate_model_free_form_layout_element_background_style(
&mut object_2586,
var_2585,
)?;
object_2586.finish();
}
if let Some(var_2587) = &input.loading_animation {
#[allow(unused_mut)]
let mut object_2588 = object.key("LoadingAnimation").start_object();
crate::json_ser::serialize_structure_crate_model_loading_animation(
&mut object_2588,
var_2587,
)?;
object_2588.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_free_form_layout_canvas_size_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FreeFormLayoutCanvasSizeOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2589) = &input.screen_canvas_size_options {
#[allow(unused_mut)]
let mut object_2590 = object.key("ScreenCanvasSizeOptions").start_object();
crate::json_ser::serialize_structure_crate_model_free_form_layout_screen_canvas_size_options(&mut object_2590, var_2589)?;
object_2590.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_header_footer_section_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HeaderFooterSectionConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2591) = &input.section_id {
object.key("SectionId").string(var_2591.as_str());
}
if let Some(var_2592) = &input.layout {
#[allow(unused_mut)]
let mut object_2593 = object.key("Layout").start_object();
crate::json_ser::serialize_structure_crate_model_section_layout_configuration(
&mut object_2593,
var_2592,
)?;
object_2593.finish();
}
if let Some(var_2594) = &input.style {
#[allow(unused_mut)]
let mut object_2595 = object.key("Style").start_object();
crate::json_ser::serialize_structure_crate_model_section_style(&mut object_2595, var_2594)?;
object_2595.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_body_section_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BodySectionConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2596) = &input.section_id {
object.key("SectionId").string(var_2596.as_str());
}
if let Some(var_2597) = &input.content {
#[allow(unused_mut)]
let mut object_2598 = object.key("Content").start_object();
crate::json_ser::serialize_structure_crate_model_body_section_content(
&mut object_2598,
var_2597,
)?;
object_2598.finish();
}
if let Some(var_2599) = &input.style {
#[allow(unused_mut)]
let mut object_2600 = object.key("Style").start_object();
crate::json_ser::serialize_structure_crate_model_section_style(&mut object_2600, var_2599)?;
object_2600.finish();
}
if let Some(var_2601) = &input.page_break_configuration {
#[allow(unused_mut)]
let mut object_2602 = object.key("PageBreakConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_section_page_break_configuration(
&mut object_2602,
var_2601,
)?;
object_2602.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_section_based_layout_canvas_size_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SectionBasedLayoutCanvasSizeOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2603) = &input.paper_canvas_size_options {
#[allow(unused_mut)]
let mut object_2604 = object.key("PaperCanvasSizeOptions").start_object();
crate::json_ser::serialize_structure_crate_model_section_based_layout_paper_canvas_size_options(&mut object_2604, var_2603)?;
object_2604.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_list_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterListConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2605) = &input.match_operator {
object.key("MatchOperator").string(var_2605.as_str());
}
if let Some(var_2606) = &input.category_values {
let mut array_2607 = object.key("CategoryValues").start_array();
for item_2608 in var_2606 {
{
array_2607.value().string(item_2608.as_str());
}
}
array_2607.finish();
}
if let Some(var_2609) = &input.select_all_options {
object.key("SelectAllOptions").string(var_2609.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_filter_list_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomFilterListConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2610) = &input.match_operator {
object.key("MatchOperator").string(var_2610.as_str());
}
if let Some(var_2611) = &input.category_values {
let mut array_2612 = object.key("CategoryValues").start_array();
for item_2613 in var_2611 {
{
array_2612.value().string(item_2613.as_str());
}
}
array_2612.finish();
}
if let Some(var_2614) = &input.select_all_options {
object.key("SelectAllOptions").string(var_2614.as_str());
}
if let Some(var_2615) = &input.null_option {
object.key("NullOption").string(var_2615.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_filter_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomFilterConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2616) = &input.match_operator {
object.key("MatchOperator").string(var_2616.as_str());
}
if let Some(var_2617) = &input.category_value {
object.key("CategoryValue").string(var_2617.as_str());
}
if let Some(var_2618) = &input.select_all_options {
object.key("SelectAllOptions").string(var_2618.as_str());
}
if let Some(var_2619) = &input.parameter_name {
object.key("ParameterName").string(var_2619.as_str());
}
if let Some(var_2620) = &input.null_option {
object.key("NullOption").string(var_2620.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_numerical_aggregation_function(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NumericalAggregationFunction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2621) = &input.simple_numerical_aggregation {
object
.key("SimpleNumericalAggregation")
.string(var_2621.as_str());
}
if let Some(var_2622) = &input.percentile_aggregation {
#[allow(unused_mut)]
let mut object_2623 = object.key("PercentileAggregation").start_object();
crate::json_ser::serialize_structure_crate_model_percentile_aggregation(
&mut object_2623,
var_2622,
)?;
object_2623.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_number_display_format_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NumberDisplayFormatConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2624) = &input.prefix {
object.key("Prefix").string(var_2624.as_str());
}
if let Some(var_2625) = &input.suffix {
object.key("Suffix").string(var_2625.as_str());
}
if let Some(var_2626) = &input.separator_configuration {
#[allow(unused_mut)]
let mut object_2627 = object.key("SeparatorConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_numeric_separator_configuration(
&mut object_2627,
var_2626,
)?;
object_2627.finish();
}
if let Some(var_2628) = &input.decimal_places_configuration {
#[allow(unused_mut)]
let mut object_2629 = object.key("DecimalPlacesConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_decimal_places_configuration(
&mut object_2629,
var_2628,
)?;
object_2629.finish();
}
if let Some(var_2630) = &input.number_scale {
object.key("NumberScale").string(var_2630.as_str());
}
if let Some(var_2631) = &input.negative_value_configuration {
#[allow(unused_mut)]
let mut object_2632 = object.key("NegativeValueConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_negative_value_configuration(
&mut object_2632,
var_2631,
)?;
object_2632.finish();
}
if let Some(var_2633) = &input.null_value_format_configuration {
#[allow(unused_mut)]
let mut object_2634 = object.key("NullValueFormatConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_null_value_format_configuration(
&mut object_2634,
var_2633,
)?;
object_2634.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_currency_display_format_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CurrencyDisplayFormatConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2635) = &input.prefix {
object.key("Prefix").string(var_2635.as_str());
}
if let Some(var_2636) = &input.suffix {
object.key("Suffix").string(var_2636.as_str());
}
if let Some(var_2637) = &input.separator_configuration {
#[allow(unused_mut)]
let mut object_2638 = object.key("SeparatorConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_numeric_separator_configuration(
&mut object_2638,
var_2637,
)?;
object_2638.finish();
}
if let Some(var_2639) = &input.symbol {
object.key("Symbol").string(var_2639.as_str());
}
if let Some(var_2640) = &input.decimal_places_configuration {
#[allow(unused_mut)]
let mut object_2641 = object.key("DecimalPlacesConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_decimal_places_configuration(
&mut object_2641,
var_2640,
)?;
object_2641.finish();
}
if let Some(var_2642) = &input.number_scale {
object.key("NumberScale").string(var_2642.as_str());
}
if let Some(var_2643) = &input.negative_value_configuration {
#[allow(unused_mut)]
let mut object_2644 = object.key("NegativeValueConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_negative_value_configuration(
&mut object_2644,
var_2643,
)?;
object_2644.finish();
}
if let Some(var_2645) = &input.null_value_format_configuration {
#[allow(unused_mut)]
let mut object_2646 = object.key("NullValueFormatConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_null_value_format_configuration(
&mut object_2646,
var_2645,
)?;
object_2646.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_percentage_display_format_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PercentageDisplayFormatConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2647) = &input.prefix {
object.key("Prefix").string(var_2647.as_str());
}
if let Some(var_2648) = &input.suffix {
object.key("Suffix").string(var_2648.as_str());
}
if let Some(var_2649) = &input.separator_configuration {
#[allow(unused_mut)]
let mut object_2650 = object.key("SeparatorConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_numeric_separator_configuration(
&mut object_2650,
var_2649,
)?;
object_2650.finish();
}
if let Some(var_2651) = &input.decimal_places_configuration {
#[allow(unused_mut)]
let mut object_2652 = object.key("DecimalPlacesConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_decimal_places_configuration(
&mut object_2652,
var_2651,
)?;
object_2652.finish();
}
if let Some(var_2653) = &input.negative_value_configuration {
#[allow(unused_mut)]
let mut object_2654 = object.key("NegativeValueConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_negative_value_configuration(
&mut object_2654,
var_2653,
)?;
object_2654.finish();
}
if let Some(var_2655) = &input.null_value_format_configuration {
#[allow(unused_mut)]
let mut object_2656 = object.key("NullValueFormatConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_null_value_format_configuration(
&mut object_2656,
var_2655,
)?;
object_2656.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_font_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FontConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2657) = &input.font_size {
#[allow(unused_mut)]
let mut object_2658 = object.key("FontSize").start_object();
crate::json_ser::serialize_structure_crate_model_font_size(&mut object_2658, var_2657)?;
object_2658.finish();
}
if let Some(var_2659) = &input.font_decoration {
object.key("FontDecoration").string(var_2659.as_str());
}
if let Some(var_2660) = &input.font_color {
object.key("FontColor").string(var_2660.as_str());
}
if let Some(var_2661) = &input.font_weight {
#[allow(unused_mut)]
let mut object_2662 = object.key("FontWeight").start_object();
crate::json_ser::serialize_structure_crate_model_font_weight(&mut object_2662, var_2661)?;
object_2662.finish();
}
if let Some(var_2663) = &input.font_style {
object.key("FontStyle").string(var_2663.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_table_aggregated_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableAggregatedFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2664) = &input.group_by {
let mut array_2665 = object.key("GroupBy").start_array();
for item_2666 in var_2664 {
{
#[allow(unused_mut)]
let mut object_2667 = array_2665.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_2667,
item_2666,
)?;
object_2667.finish();
}
}
array_2665.finish();
}
if let Some(var_2668) = &input.values {
let mut array_2669 = object.key("Values").start_array();
for item_2670 in var_2668 {
{
#[allow(unused_mut)]
let mut object_2671 = array_2669.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_2671,
item_2670,
)?;
object_2671.finish();
}
}
array_2669.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_table_unaggregated_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableUnaggregatedFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2672) = &input.values {
let mut array_2673 = object.key("Values").start_array();
for item_2674 in var_2672 {
{
#[allow(unused_mut)]
let mut object_2675 = array_2673.value().start_object();
crate::json_ser::serialize_structure_crate_model_unaggregated_field(
&mut object_2675,
item_2674,
)?;
object_2675.finish();
}
}
array_2673.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_field_sort_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FieldSortOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2676) = &input.field_sort {
#[allow(unused_mut)]
let mut object_2677 = object.key("FieldSort").start_object();
crate::json_ser::serialize_structure_crate_model_field_sort(&mut object_2677, var_2676)?;
object_2677.finish();
}
if let Some(var_2678) = &input.column_sort {
#[allow(unused_mut)]
let mut object_2679 = object.key("ColumnSort").start_object();
crate::json_ser::serialize_structure_crate_model_column_sort(&mut object_2679, var_2678)?;
object_2679.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pagination_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PaginationConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2680) = &input.page_size {
object.key("PageSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2680).into()),
);
}
if let Some(var_2681) = &input.page_number {
object.key("PageNumber").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2681).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_table_cell_style(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableCellStyle,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2682) = &input.visibility {
object.key("Visibility").string(var_2682.as_str());
}
if let Some(var_2683) = &input.font_configuration {
#[allow(unused_mut)]
let mut object_2684 = object.key("FontConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_font_configuration(
&mut object_2684,
var_2683,
)?;
object_2684.finish();
}
if let Some(var_2685) = &input.text_wrap {
object.key("TextWrap").string(var_2685.as_str());
}
if let Some(var_2686) = &input.horizontal_text_alignment {
object
.key("HorizontalTextAlignment")
.string(var_2686.as_str());
}
if let Some(var_2687) = &input.vertical_text_alignment {
object
.key("VerticalTextAlignment")
.string(var_2687.as_str());
}
if let Some(var_2688) = &input.background_color {
object.key("BackgroundColor").string(var_2688.as_str());
}
if let Some(var_2689) = &input.height {
object.key("Height").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2689).into()),
);
}
if let Some(var_2690) = &input.border {
#[allow(unused_mut)]
let mut object_2691 = object.key("Border").start_object();
crate::json_ser::serialize_structure_crate_model_global_table_border_options(
&mut object_2691,
var_2690,
)?;
object_2691.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_row_alternate_color_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RowAlternateColorOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2692) = &input.status {
object.key("Status").string(var_2692.as_str());
}
if let Some(var_2693) = &input.row_alternate_colors {
let mut array_2694 = object.key("RowAlternateColors").start_array();
for item_2695 in var_2693 {
{
array_2694.value().string(item_2695.as_str());
}
}
array_2694.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_table_field_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableFieldOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2696) = &input.field_id {
object.key("FieldId").string(var_2696.as_str());
}
if let Some(var_2697) = &input.width {
object.key("Width").string(var_2697.as_str());
}
if let Some(var_2698) = &input.custom_label {
object.key("CustomLabel").string(var_2698.as_str());
}
if let Some(var_2699) = &input.visibility {
object.key("Visibility").string(var_2699.as_str());
}
if let Some(var_2700) = &input.url_styling {
#[allow(unused_mut)]
let mut object_2701 = object.key("URLStyling").start_object();
crate::json_ser::serialize_structure_crate_model_table_field_url_configuration(
&mut object_2701,
var_2700,
)?;
object_2701.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_data_bars_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataBarsOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2702) = &input.field_id {
object.key("FieldId").string(var_2702.as_str());
}
if let Some(var_2703) = &input.positive_color {
object.key("PositiveColor").string(var_2703.as_str());
}
if let Some(var_2704) = &input.negative_color {
object.key("NegativeColor").string(var_2704.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_table_cell_conditional_formatting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableCellConditionalFormatting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2705) = &input.field_id {
object.key("FieldId").string(var_2705.as_str());
}
if let Some(var_2706) = &input.text_format {
#[allow(unused_mut)]
let mut object_2707 = object.key("TextFormat").start_object();
crate::json_ser::serialize_structure_crate_model_text_conditional_format(
&mut object_2707,
var_2706,
)?;
object_2707.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_table_row_conditional_formatting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableRowConditionalFormatting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2708) = &input.background_color {
#[allow(unused_mut)]
let mut object_2709 = object.key("BackgroundColor").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_formatting_color(
&mut object_2709,
var_2708,
)?;
object_2709.finish();
}
if let Some(var_2710) = &input.text_color {
#[allow(unused_mut)]
let mut object_2711 = object.key("TextColor").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_formatting_color(
&mut object_2711,
var_2710,
)?;
object_2711.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_action_filter_operation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomActionFilterOperation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2712) = &input.selected_fields_configuration {
#[allow(unused_mut)]
let mut object_2713 = object.key("SelectedFieldsConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_filter_operation_selected_fields_configuration(&mut object_2713, var_2712)?;
object_2713.finish();
}
if let Some(var_2714) = &input.target_visuals_configuration {
#[allow(unused_mut)]
let mut object_2715 = object.key("TargetVisualsConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_filter_operation_target_visuals_configuration(&mut object_2715, var_2714)?;
object_2715.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_action_navigation_operation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomActionNavigationOperation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2716) = &input.local_navigation_configuration {
#[allow(unused_mut)]
let mut object_2717 = object.key("LocalNavigationConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_local_navigation_configuration(
&mut object_2717,
var_2716,
)?;
object_2717.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_action_url_operation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomActionUrlOperation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2718) = &input.url_template {
object.key("URLTemplate").string(var_2718.as_str());
}
if let Some(var_2719) = &input.url_target {
object.key("URLTarget").string(var_2719.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_action_set_parameters_operation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomActionSetParametersOperation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2720) = &input.parameter_value_configurations {
let mut array_2721 = object.key("ParameterValueConfigurations").start_array();
for item_2722 in var_2720 {
{
#[allow(unused_mut)]
let mut object_2723 = array_2721.value().start_object();
crate::json_ser::serialize_structure_crate_model_set_parameter_value_configuration(
&mut object_2723,
item_2722,
)?;
object_2723.finish();
}
}
array_2721.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pivot_table_aggregated_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PivotTableAggregatedFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2724) = &input.rows {
let mut array_2725 = object.key("Rows").start_array();
for item_2726 in var_2724 {
{
#[allow(unused_mut)]
let mut object_2727 = array_2725.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_2727,
item_2726,
)?;
object_2727.finish();
}
}
array_2725.finish();
}
if let Some(var_2728) = &input.columns {
let mut array_2729 = object.key("Columns").start_array();
for item_2730 in var_2728 {
{
#[allow(unused_mut)]
let mut object_2731 = array_2729.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_2731,
item_2730,
)?;
object_2731.finish();
}
}
array_2729.finish();
}
if let Some(var_2732) = &input.values {
let mut array_2733 = object.key("Values").start_array();
for item_2734 in var_2732 {
{
#[allow(unused_mut)]
let mut object_2735 = array_2733.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_2735,
item_2734,
)?;
object_2735.finish();
}
}
array_2733.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pivot_field_sort_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PivotFieldSortOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2736) = &input.field_id {
object.key("FieldId").string(var_2736.as_str());
}
if let Some(var_2737) = &input.sort_by {
#[allow(unused_mut)]
let mut object_2738 = object.key("SortBy").start_object();
crate::json_ser::serialize_structure_crate_model_pivot_table_sort_by(
&mut object_2738,
var_2737,
)?;
object_2738.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_subtotal_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SubtotalOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2739) = &input.totals_visibility {
object.key("TotalsVisibility").string(var_2739.as_str());
}
if let Some(var_2740) = &input.custom_label {
object.key("CustomLabel").string(var_2740.as_str());
}
if let Some(var_2741) = &input.field_level {
object.key("FieldLevel").string(var_2741.as_str());
}
if let Some(var_2742) = &input.field_level_options {
let mut array_2743 = object.key("FieldLevelOptions").start_array();
for item_2744 in var_2742 {
{
#[allow(unused_mut)]
let mut object_2745 = array_2743.value().start_object();
crate::json_ser::serialize_structure_crate_model_pivot_table_field_subtotal_options(&mut object_2745, item_2744)?;
object_2745.finish();
}
}
array_2743.finish();
}
if let Some(var_2746) = &input.total_cell_style {
#[allow(unused_mut)]
let mut object_2747 = object.key("TotalCellStyle").start_object();
crate::json_ser::serialize_structure_crate_model_table_cell_style(
&mut object_2747,
var_2746,
)?;
object_2747.finish();
}
if let Some(var_2748) = &input.value_cell_style {
#[allow(unused_mut)]
let mut object_2749 = object.key("ValueCellStyle").start_object();
crate::json_ser::serialize_structure_crate_model_table_cell_style(
&mut object_2749,
var_2748,
)?;
object_2749.finish();
}
if let Some(var_2750) = &input.metric_header_cell_style {
#[allow(unused_mut)]
let mut object_2751 = object.key("MetricHeaderCellStyle").start_object();
crate::json_ser::serialize_structure_crate_model_table_cell_style(
&mut object_2751,
var_2750,
)?;
object_2751.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pivot_total_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PivotTotalOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2752) = &input.totals_visibility {
object.key("TotalsVisibility").string(var_2752.as_str());
}
if let Some(var_2753) = &input.placement {
object.key("Placement").string(var_2753.as_str());
}
if let Some(var_2754) = &input.scroll_status {
object.key("ScrollStatus").string(var_2754.as_str());
}
if let Some(var_2755) = &input.custom_label {
object.key("CustomLabel").string(var_2755.as_str());
}
if let Some(var_2756) = &input.total_cell_style {
#[allow(unused_mut)]
let mut object_2757 = object.key("TotalCellStyle").start_object();
crate::json_ser::serialize_structure_crate_model_table_cell_style(
&mut object_2757,
var_2756,
)?;
object_2757.finish();
}
if let Some(var_2758) = &input.value_cell_style {
#[allow(unused_mut)]
let mut object_2759 = object.key("ValueCellStyle").start_object();
crate::json_ser::serialize_structure_crate_model_table_cell_style(
&mut object_2759,
var_2758,
)?;
object_2759.finish();
}
if let Some(var_2760) = &input.metric_header_cell_style {
#[allow(unused_mut)]
let mut object_2761 = object.key("MetricHeaderCellStyle").start_object();
crate::json_ser::serialize_structure_crate_model_table_cell_style(
&mut object_2761,
var_2760,
)?;
object_2761.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pivot_table_field_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PivotTableFieldOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2762) = &input.field_id {
object.key("FieldId").string(var_2762.as_str());
}
if let Some(var_2763) = &input.custom_label {
object.key("CustomLabel").string(var_2763.as_str());
}
if let Some(var_2764) = &input.visibility {
object.key("Visibility").string(var_2764.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_pivot_table_data_path_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PivotTableDataPathOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2765) = &input.data_path_list {
let mut array_2766 = object.key("DataPathList").start_array();
for item_2767 in var_2765 {
{
#[allow(unused_mut)]
let mut object_2768 = array_2766.value().start_object();
crate::json_ser::serialize_structure_crate_model_data_path_value(
&mut object_2768,
item_2767,
)?;
object_2768.finish();
}
}
array_2766.finish();
}
if let Some(var_2769) = &input.width {
object.key("Width").string(var_2769.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_pivot_table_cell_conditional_formatting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PivotTableCellConditionalFormatting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2770) = &input.field_id {
object.key("FieldId").string(var_2770.as_str());
}
if let Some(var_2771) = &input.text_format {
#[allow(unused_mut)]
let mut object_2772 = object.key("TextFormat").start_object();
crate::json_ser::serialize_structure_crate_model_text_conditional_format(
&mut object_2772,
var_2771,
)?;
object_2772.finish();
}
if let Some(var_2773) = &input.scope {
#[allow(unused_mut)]
let mut object_2774 = object.key("Scope").start_object();
crate::json_ser::serialize_structure_crate_model_pivot_table_conditional_formatting_scope(
&mut object_2774,
var_2773,
)?;
object_2774.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_bar_chart_aggregated_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BarChartAggregatedFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2775) = &input.category {
let mut array_2776 = object.key("Category").start_array();
for item_2777 in var_2775 {
{
#[allow(unused_mut)]
let mut object_2778 = array_2776.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_2778,
item_2777,
)?;
object_2778.finish();
}
}
array_2776.finish();
}
if let Some(var_2779) = &input.values {
let mut array_2780 = object.key("Values").start_array();
for item_2781 in var_2779 {
{
#[allow(unused_mut)]
let mut object_2782 = array_2780.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_2782,
item_2781,
)?;
object_2782.finish();
}
}
array_2780.finish();
}
if let Some(var_2783) = &input.colors {
let mut array_2784 = object.key("Colors").start_array();
for item_2785 in var_2783 {
{
#[allow(unused_mut)]
let mut object_2786 = array_2784.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_2786,
item_2785,
)?;
object_2786.finish();
}
}
array_2784.finish();
}
if let Some(var_2787) = &input.small_multiples {
let mut array_2788 = object.key("SmallMultiples").start_array();
for item_2789 in var_2787 {
{
#[allow(unused_mut)]
let mut object_2790 = array_2788.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_2790,
item_2789,
)?;
object_2790.finish();
}
}
array_2788.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_items_limit_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ItemsLimitConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2791) = &input.items_limit {
object.key("ItemsLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2791).into()),
);
}
if let Some(var_2792) = &input.other_categories {
object.key("OtherCategories").string(var_2792.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_data_path_color(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataPathColor,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2793) = &input.element {
#[allow(unused_mut)]
let mut object_2794 = object.key("Element").start_object();
crate::json_ser::serialize_structure_crate_model_data_path_value(
&mut object_2794,
var_2793,
)?;
object_2794.finish();
}
if let Some(var_2795) = &input.color {
object.key("Color").string(var_2795.as_str());
}
if let Some(var_2796) = &input.time_granularity {
object.key("TimeGranularity").string(var_2796.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_panel_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PanelConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2797) = &input.title {
#[allow(unused_mut)]
let mut object_2798 = object.key("Title").start_object();
crate::json_ser::serialize_structure_crate_model_panel_title_options(
&mut object_2798,
var_2797,
)?;
object_2798.finish();
}
if let Some(var_2799) = &input.border_visibility {
object.key("BorderVisibility").string(var_2799.as_str());
}
if let Some(var_2800) = &input.border_thickness {
object.key("BorderThickness").string(var_2800.as_str());
}
if let Some(var_2801) = &input.border_style {
object.key("BorderStyle").string(var_2801.as_str());
}
if let Some(var_2802) = &input.border_color {
object.key("BorderColor").string(var_2802.as_str());
}
if let Some(var_2803) = &input.gutter_visibility {
object.key("GutterVisibility").string(var_2803.as_str());
}
if let Some(var_2804) = &input.gutter_spacing {
object.key("GutterSpacing").string(var_2804.as_str());
}
if let Some(var_2805) = &input.background_visibility {
object.key("BackgroundVisibility").string(var_2805.as_str());
}
if let Some(var_2806) = &input.background_color {
object.key("BackgroundColor").string(var_2806.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_axis_tick_label_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AxisTickLabelOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2807) = &input.label_options {
#[allow(unused_mut)]
let mut object_2808 = object.key("LabelOptions").start_object();
crate::json_ser::serialize_structure_crate_model_label_options(&mut object_2808, var_2807)?;
object_2808.finish();
}
if let Some(var_2809) = &input.rotation_angle {
object.key("RotationAngle").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_2809).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_axis_data_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AxisDataOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2810) = &input.numeric_axis_options {
#[allow(unused_mut)]
let mut object_2811 = object.key("NumericAxisOptions").start_object();
crate::json_ser::serialize_structure_crate_model_numeric_axis_options(
&mut object_2811,
var_2810,
)?;
object_2811.finish();
}
if let Some(var_2812) = &input.date_axis_options {
#[allow(unused_mut)]
let mut object_2813 = object.key("DateAxisOptions").start_object();
crate::json_ser::serialize_structure_crate_model_date_axis_options(
&mut object_2813,
var_2812,
)?;
object_2813.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_scroll_bar_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ScrollBarOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2814) = &input.visibility {
object.key("Visibility").string(var_2814.as_str());
}
if let Some(var_2815) = &input.visible_range {
#[allow(unused_mut)]
let mut object_2816 = object.key("VisibleRange").start_object();
crate::json_ser::serialize_structure_crate_model_visible_range_options(
&mut object_2816,
var_2815,
)?;
object_2816.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_axis_label_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AxisLabelOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2817) = &input.font_configuration {
#[allow(unused_mut)]
let mut object_2818 = object.key("FontConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_font_configuration(
&mut object_2818,
var_2817,
)?;
object_2818.finish();
}
if let Some(var_2819) = &input.custom_label {
object.key("CustomLabel").string(var_2819.as_str());
}
if let Some(var_2820) = &input.apply_to {
#[allow(unused_mut)]
let mut object_2821 = object.key("ApplyTo").start_object();
crate::json_ser::serialize_structure_crate_model_axis_label_reference_options(
&mut object_2821,
var_2820,
)?;
object_2821.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_data_label_type(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataLabelType,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2822) = &input.field_label_type {
#[allow(unused_mut)]
let mut object_2823 = object.key("FieldLabelType").start_object();
crate::json_ser::serialize_structure_crate_model_field_label_type(
&mut object_2823,
var_2822,
)?;
object_2823.finish();
}
if let Some(var_2824) = &input.data_path_label_type {
#[allow(unused_mut)]
let mut object_2825 = object.key("DataPathLabelType").start_object();
crate::json_ser::serialize_structure_crate_model_data_path_label_type(
&mut object_2825,
var_2824,
)?;
object_2825.finish();
}
if let Some(var_2826) = &input.range_ends_label_type {
#[allow(unused_mut)]
let mut object_2827 = object.key("RangeEndsLabelType").start_object();
crate::json_ser::serialize_structure_crate_model_range_ends_label_type(
&mut object_2827,
var_2826,
)?;
object_2827.finish();
}
if let Some(var_2828) = &input.minimum_label_type {
#[allow(unused_mut)]
let mut object_2829 = object.key("MinimumLabelType").start_object();
crate::json_ser::serialize_structure_crate_model_minimum_label_type(
&mut object_2829,
var_2828,
)?;
object_2829.finish();
}
if let Some(var_2830) = &input.maximum_label_type {
#[allow(unused_mut)]
let mut object_2831 = object.key("MaximumLabelType").start_object();
crate::json_ser::serialize_structure_crate_model_maximum_label_type(
&mut object_2831,
var_2830,
)?;
object_2831.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_field_based_tooltip(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FieldBasedTooltip,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2832) = &input.aggregation_visibility {
object
.key("AggregationVisibility")
.string(var_2832.as_str());
}
if let Some(var_2833) = &input.tooltip_title_type {
object.key("TooltipTitleType").string(var_2833.as_str());
}
if let Some(var_2834) = &input.tooltip_fields {
let mut array_2835 = object.key("TooltipFields").start_array();
for item_2836 in var_2834 {
{
#[allow(unused_mut)]
let mut object_2837 = array_2835.value().start_object();
crate::json_ser::serialize_structure_crate_model_tooltip_item(
&mut object_2837,
item_2836,
)?;
object_2837.finish();
}
}
array_2835.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_reference_line_data_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReferenceLineDataConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2838) = &input.static_configuration {
#[allow(unused_mut)]
let mut object_2839 = object.key("StaticConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_reference_line_static_data_configuration(
&mut object_2839,
var_2838,
)?;
object_2839.finish();
}
if let Some(var_2840) = &input.dynamic_configuration {
#[allow(unused_mut)]
let mut object_2841 = object.key("DynamicConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_reference_line_dynamic_data_configuration(
&mut object_2841,
var_2840,
)?;
object_2841.finish();
}
if let Some(var_2842) = &input.axis_binding {
object.key("AxisBinding").string(var_2842.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_reference_line_style_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReferenceLineStyleConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2843) = &input.pattern {
object.key("Pattern").string(var_2843.as_str());
}
if let Some(var_2844) = &input.color {
object.key("Color").string(var_2844.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_reference_line_label_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReferenceLineLabelConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2845) = &input.value_label_configuration {
#[allow(unused_mut)]
let mut object_2846 = object.key("ValueLabelConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_reference_line_value_label_configuration(
&mut object_2846,
var_2845,
)?;
object_2846.finish();
}
if let Some(var_2847) = &input.custom_label_configuration {
#[allow(unused_mut)]
let mut object_2848 = object.key("CustomLabelConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_reference_line_custom_label_configuration(
&mut object_2848,
var_2847,
)?;
object_2848.finish();
}
if let Some(var_2849) = &input.font_configuration {
#[allow(unused_mut)]
let mut object_2850 = object.key("FontConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_font_configuration(
&mut object_2850,
var_2849,
)?;
object_2850.finish();
}
if let Some(var_2851) = &input.font_color {
object.key("FontColor").string(var_2851.as_str());
}
if let Some(var_2852) = &input.horizontal_position {
object.key("HorizontalPosition").string(var_2852.as_str());
}
if let Some(var_2853) = &input.vertical_position {
object.key("VerticalPosition").string(var_2853.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_drill_down_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DrillDownFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2854) = &input.numeric_equality_filter {
#[allow(unused_mut)]
let mut object_2855 = object.key("NumericEqualityFilter").start_object();
crate::json_ser::serialize_structure_crate_model_numeric_equality_drill_down_filter(
&mut object_2855,
var_2854,
)?;
object_2855.finish();
}
if let Some(var_2856) = &input.category_filter {
#[allow(unused_mut)]
let mut object_2857 = object.key("CategoryFilter").start_object();
crate::json_ser::serialize_structure_crate_model_category_drill_down_filter(
&mut object_2857,
var_2856,
)?;
object_2857.finish();
}
if let Some(var_2858) = &input.time_range_filter {
#[allow(unused_mut)]
let mut object_2859 = object.key("TimeRangeFilter").start_object();
crate::json_ser::serialize_structure_crate_model_time_range_drill_down_filter(
&mut object_2859,
var_2858,
)?;
object_2859.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_measure_field(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MeasureField,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2860) = &input.numerical_measure_field {
#[allow(unused_mut)]
let mut object_2861 = object.key("NumericalMeasureField").start_object();
crate::json_ser::serialize_structure_crate_model_numerical_measure_field(
&mut object_2861,
var_2860,
)?;
object_2861.finish();
}
if let Some(var_2862) = &input.categorical_measure_field {
#[allow(unused_mut)]
let mut object_2863 = object.key("CategoricalMeasureField").start_object();
crate::json_ser::serialize_structure_crate_model_categorical_measure_field(
&mut object_2863,
var_2862,
)?;
object_2863.finish();
}
if let Some(var_2864) = &input.date_measure_field {
#[allow(unused_mut)]
let mut object_2865 = object.key("DateMeasureField").start_object();
crate::json_ser::serialize_structure_crate_model_date_measure_field(
&mut object_2865,
var_2864,
)?;
object_2865.finish();
}
if let Some(var_2866) = &input.calculated_measure_field {
#[allow(unused_mut)]
let mut object_2867 = object.key("CalculatedMeasureField").start_object();
crate::json_ser::serialize_structure_crate_model_calculated_measure_field(
&mut object_2867,
var_2866,
)?;
object_2867.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_dimension_field(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DimensionField,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2868) = &input.numerical_dimension_field {
#[allow(unused_mut)]
let mut object_2869 = object.key("NumericalDimensionField").start_object();
crate::json_ser::serialize_structure_crate_model_numerical_dimension_field(
&mut object_2869,
var_2868,
)?;
object_2869.finish();
}
if let Some(var_2870) = &input.categorical_dimension_field {
#[allow(unused_mut)]
let mut object_2871 = object.key("CategoricalDimensionField").start_object();
crate::json_ser::serialize_structure_crate_model_categorical_dimension_field(
&mut object_2871,
var_2870,
)?;
object_2871.finish();
}
if let Some(var_2872) = &input.date_dimension_field {
#[allow(unused_mut)]
let mut object_2873 = object.key("DateDimensionField").start_object();
crate::json_ser::serialize_structure_crate_model_date_dimension_field(
&mut object_2873,
var_2872,
)?;
object_2873.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_progress_bar_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProgressBarOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2874) = &input.visibility {
object.key("Visibility").string(var_2874.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_trend_arrow_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TrendArrowOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2875) = &input.visibility {
object.key("Visibility").string(var_2875.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_secondary_value_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SecondaryValueOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2876) = &input.visibility {
object.key("Visibility").string(var_2876.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_comparison_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComparisonConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2877) = &input.comparison_method {
object.key("ComparisonMethod").string(var_2877.as_str());
}
if let Some(var_2878) = &input.comparison_format {
#[allow(unused_mut)]
let mut object_2879 = object.key("ComparisonFormat").start_object();
crate::json_ser::serialize_structure_crate_model_comparison_format_configuration(
&mut object_2879,
var_2878,
)?;
object_2879.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_kpi_primary_value_conditional_formatting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KpiPrimaryValueConditionalFormatting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2880) = &input.text_color {
#[allow(unused_mut)]
let mut object_2881 = object.key("TextColor").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_formatting_color(
&mut object_2881,
var_2880,
)?;
object_2881.finish();
}
if let Some(var_2882) = &input.icon {
#[allow(unused_mut)]
let mut object_2883 = object.key("Icon").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_formatting_icon(
&mut object_2883,
var_2882,
)?;
object_2883.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_kpi_progress_bar_conditional_formatting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KpiProgressBarConditionalFormatting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2884) = &input.foreground_color {
#[allow(unused_mut)]
let mut object_2885 = object.key("ForegroundColor").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_formatting_color(
&mut object_2885,
var_2884,
)?;
object_2885.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pie_chart_aggregated_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PieChartAggregatedFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2886) = &input.category {
let mut array_2887 = object.key("Category").start_array();
for item_2888 in var_2886 {
{
#[allow(unused_mut)]
let mut object_2889 = array_2887.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_2889,
item_2888,
)?;
object_2889.finish();
}
}
array_2887.finish();
}
if let Some(var_2890) = &input.values {
let mut array_2891 = object.key("Values").start_array();
for item_2892 in var_2890 {
{
#[allow(unused_mut)]
let mut object_2893 = array_2891.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_2893,
item_2892,
)?;
object_2893.finish();
}
}
array_2891.finish();
}
if let Some(var_2894) = &input.small_multiples {
let mut array_2895 = object.key("SmallMultiples").start_array();
for item_2896 in var_2894 {
{
#[allow(unused_mut)]
let mut object_2897 = array_2895.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_2897,
item_2896,
)?;
object_2897.finish();
}
}
array_2895.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_arc_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ArcOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2898) = &input.arc_thickness {
object.key("ArcThickness").string(var_2898.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_donut_center_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DonutCenterOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2899) = &input.label_visibility {
object.key("LabelVisibility").string(var_2899.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_arc_axis_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ArcAxisConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2900) = &input.range {
#[allow(unused_mut)]
let mut object_2901 = object.key("Range").start_object();
crate::json_ser::serialize_structure_crate_model_arc_axis_display_range(
&mut object_2901,
var_2900,
)?;
object_2901.finish();
}
if input.reserve_range != 0 {
object.key("ReserveRange").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.reserve_range).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_arc_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ArcConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2902) = &input.arc_angle {
object.key("ArcAngle").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_2902).into()),
);
}
if let Some(var_2903) = &input.arc_thickness {
object.key("ArcThickness").string(var_2903.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_gauge_chart_primary_value_conditional_formatting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GaugeChartPrimaryValueConditionalFormatting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2904) = &input.text_color {
#[allow(unused_mut)]
let mut object_2905 = object.key("TextColor").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_formatting_color(
&mut object_2905,
var_2904,
)?;
object_2905.finish();
}
if let Some(var_2906) = &input.icon {
#[allow(unused_mut)]
let mut object_2907 = object.key("Icon").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_formatting_icon(
&mut object_2907,
var_2906,
)?;
object_2907.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_gauge_chart_arc_conditional_formatting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GaugeChartArcConditionalFormatting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2908) = &input.foreground_color {
#[allow(unused_mut)]
let mut object_2909 = object.key("ForegroundColor").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_formatting_color(
&mut object_2909,
var_2908,
)?;
object_2909.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_line_chart_aggregated_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LineChartAggregatedFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2910) = &input.category {
let mut array_2911 = object.key("Category").start_array();
for item_2912 in var_2910 {
{
#[allow(unused_mut)]
let mut object_2913 = array_2911.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_2913,
item_2912,
)?;
object_2913.finish();
}
}
array_2911.finish();
}
if let Some(var_2914) = &input.values {
let mut array_2915 = object.key("Values").start_array();
for item_2916 in var_2914 {
{
#[allow(unused_mut)]
let mut object_2917 = array_2915.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_2917,
item_2916,
)?;
object_2917.finish();
}
}
array_2915.finish();
}
if let Some(var_2918) = &input.colors {
let mut array_2919 = object.key("Colors").start_array();
for item_2920 in var_2918 {
{
#[allow(unused_mut)]
let mut object_2921 = array_2919.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_2921,
item_2920,
)?;
object_2921.finish();
}
}
array_2919.finish();
}
if let Some(var_2922) = &input.small_multiples {
let mut array_2923 = object.key("SmallMultiples").start_array();
for item_2924 in var_2922 {
{
#[allow(unused_mut)]
let mut object_2925 = array_2923.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_2925,
item_2924,
)?;
object_2925.finish();
}
}
array_2923.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_time_based_forecast_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimeBasedForecastProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2926) = &input.periods_forward {
object.key("PeriodsForward").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2926).into()),
);
}
if let Some(var_2927) = &input.periods_backward {
object.key("PeriodsBackward").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2927).into()),
);
}
if let Some(var_2928) = &input.upper_boundary {
object.key("UpperBoundary").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_2928).into()),
);
}
if let Some(var_2929) = &input.lower_boundary {
object.key("LowerBoundary").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_2929).into()),
);
}
if let Some(var_2930) = &input.prediction_interval {
object.key("PredictionInterval").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2930).into()),
);
}
if let Some(var_2931) = &input.seasonality {
object.key("Seasonality").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2931).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_forecast_scenario(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ForecastScenario,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2932) = &input.what_if_point_scenario {
#[allow(unused_mut)]
let mut object_2933 = object.key("WhatIfPointScenario").start_object();
crate::json_ser::serialize_structure_crate_model_what_if_point_scenario(
&mut object_2933,
var_2932,
)?;
object_2933.finish();
}
if let Some(var_2934) = &input.what_if_range_scenario {
#[allow(unused_mut)]
let mut object_2935 = object.key("WhatIfRangeScenario").start_object();
crate::json_ser::serialize_structure_crate_model_what_if_range_scenario(
&mut object_2935,
var_2934,
)?;
object_2935.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_missing_data_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MissingDataConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2936) = &input.treatment_option {
object.key("TreatmentOption").string(var_2936.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_line_chart_line_style_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LineChartLineStyleSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2937) = &input.line_visibility {
object.key("LineVisibility").string(var_2937.as_str());
}
if let Some(var_2938) = &input.line_interpolation {
object.key("LineInterpolation").string(var_2938.as_str());
}
if let Some(var_2939) = &input.line_style {
object.key("LineStyle").string(var_2939.as_str());
}
if let Some(var_2940) = &input.line_width {
object.key("LineWidth").string(var_2940.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_line_chart_marker_style_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LineChartMarkerStyleSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2941) = &input.marker_visibility {
object.key("MarkerVisibility").string(var_2941.as_str());
}
if let Some(var_2942) = &input.marker_shape {
object.key("MarkerShape").string(var_2942.as_str());
}
if let Some(var_2943) = &input.marker_size {
object.key("MarkerSize").string(var_2943.as_str());
}
if let Some(var_2944) = &input.marker_color {
object.key("MarkerColor").string(var_2944.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_field_series_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FieldSeriesItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2945) = &input.field_id {
object.key("FieldId").string(var_2945.as_str());
}
if let Some(var_2946) = &input.axis_binding {
object.key("AxisBinding").string(var_2946.as_str());
}
if let Some(var_2947) = &input.settings {
#[allow(unused_mut)]
let mut object_2948 = object.key("Settings").start_object();
crate::json_ser::serialize_structure_crate_model_line_chart_series_settings(
&mut object_2948,
var_2947,
)?;
object_2948.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_data_field_series_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataFieldSeriesItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2949) = &input.field_id {
object.key("FieldId").string(var_2949.as_str());
}
if let Some(var_2950) = &input.field_value {
object.key("FieldValue").string(var_2950.as_str());
}
if let Some(var_2951) = &input.axis_binding {
object.key("AxisBinding").string(var_2951.as_str());
}
if let Some(var_2952) = &input.settings {
#[allow(unused_mut)]
let mut object_2953 = object.key("Settings").start_object();
crate::json_ser::serialize_structure_crate_model_line_chart_series_settings(
&mut object_2953,
var_2952,
)?;
object_2953.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_heat_map_aggregated_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HeatMapAggregatedFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2954) = &input.rows {
let mut array_2955 = object.key("Rows").start_array();
for item_2956 in var_2954 {
{
#[allow(unused_mut)]
let mut object_2957 = array_2955.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_2957,
item_2956,
)?;
object_2957.finish();
}
}
array_2955.finish();
}
if let Some(var_2958) = &input.columns {
let mut array_2959 = object.key("Columns").start_array();
for item_2960 in var_2958 {
{
#[allow(unused_mut)]
let mut object_2961 = array_2959.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_2961,
item_2960,
)?;
object_2961.finish();
}
}
array_2959.finish();
}
if let Some(var_2962) = &input.values {
let mut array_2963 = object.key("Values").start_array();
for item_2964 in var_2962 {
{
#[allow(unused_mut)]
let mut object_2965 = array_2963.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_2965,
item_2964,
)?;
object_2965.finish();
}
}
array_2963.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_data_color(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataColor,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2966) = &input.color {
object.key("Color").string(var_2966.as_str());
}
if let Some(var_2967) = &input.data_value {
object.key("DataValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_2967).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_tree_map_aggregated_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TreeMapAggregatedFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2968) = &input.groups {
let mut array_2969 = object.key("Groups").start_array();
for item_2970 in var_2968 {
{
#[allow(unused_mut)]
let mut object_2971 = array_2969.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_2971,
item_2970,
)?;
object_2971.finish();
}
}
array_2969.finish();
}
if let Some(var_2972) = &input.sizes {
let mut array_2973 = object.key("Sizes").start_array();
for item_2974 in var_2972 {
{
#[allow(unused_mut)]
let mut object_2975 = array_2973.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_2975,
item_2974,
)?;
object_2975.finish();
}
}
array_2973.finish();
}
if let Some(var_2976) = &input.colors {
let mut array_2977 = object.key("Colors").start_array();
for item_2978 in var_2976 {
{
#[allow(unused_mut)]
let mut object_2979 = array_2977.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_2979,
item_2978,
)?;
object_2979.finish();
}
}
array_2977.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_geospatial_map_aggregated_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GeospatialMapAggregatedFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2980) = &input.geospatial {
let mut array_2981 = object.key("Geospatial").start_array();
for item_2982 in var_2980 {
{
#[allow(unused_mut)]
let mut object_2983 = array_2981.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_2983,
item_2982,
)?;
object_2983.finish();
}
}
array_2981.finish();
}
if let Some(var_2984) = &input.values {
let mut array_2985 = object.key("Values").start_array();
for item_2986 in var_2984 {
{
#[allow(unused_mut)]
let mut object_2987 = array_2985.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_2987,
item_2986,
)?;
object_2987.finish();
}
}
array_2985.finish();
}
if let Some(var_2988) = &input.colors {
let mut array_2989 = object.key("Colors").start_array();
for item_2990 in var_2988 {
{
#[allow(unused_mut)]
let mut object_2991 = array_2989.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_2991,
item_2990,
)?;
object_2991.finish();
}
}
array_2989.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_geospatial_coordinate_bounds(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GeospatialCoordinateBounds,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2992) = &input.north {
object.key("North").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_2992).into()),
);
}
if let Some(var_2993) = &input.south {
object.key("South").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_2993).into()),
);
}
if let Some(var_2994) = &input.west {
object.key("West").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_2994).into()),
);
}
if let Some(var_2995) = &input.east {
object.key("East").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_2995).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_cluster_marker_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ClusterMarkerConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2996) = &input.cluster_marker {
#[allow(unused_mut)]
let mut object_2997 = object.key("ClusterMarker").start_object();
crate::json_ser::serialize_structure_crate_model_cluster_marker(
&mut object_2997,
var_2996,
)?;
object_2997.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filled_map_aggregated_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilledMapAggregatedFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2998) = &input.geospatial {
let mut array_2999 = object.key("Geospatial").start_array();
for item_3000 in var_2998 {
{
#[allow(unused_mut)]
let mut object_3001 = array_2999.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_3001,
item_3000,
)?;
object_3001.finish();
}
}
array_2999.finish();
}
if let Some(var_3002) = &input.values {
let mut array_3003 = object.key("Values").start_array();
for item_3004 in var_3002 {
{
#[allow(unused_mut)]
let mut object_3005 = array_3003.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_3005,
item_3004,
)?;
object_3005.finish();
}
}
array_3003.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filled_map_shape_conditional_formatting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilledMapShapeConditionalFormatting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3006) = &input.field_id {
object.key("FieldId").string(var_3006.as_str());
}
if let Some(var_3007) = &input.format {
#[allow(unused_mut)]
let mut object_3008 = object.key("Format").start_object();
crate::json_ser::serialize_structure_crate_model_shape_conditional_format(
&mut object_3008,
var_3007,
)?;
object_3008.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_funnel_chart_aggregated_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FunnelChartAggregatedFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3009) = &input.category {
let mut array_3010 = object.key("Category").start_array();
for item_3011 in var_3009 {
{
#[allow(unused_mut)]
let mut object_3012 = array_3010.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_3012,
item_3011,
)?;
object_3012.finish();
}
}
array_3010.finish();
}
if let Some(var_3013) = &input.values {
let mut array_3014 = object.key("Values").start_array();
for item_3015 in var_3013 {
{
#[allow(unused_mut)]
let mut object_3016 = array_3014.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_3016,
item_3015,
)?;
object_3016.finish();
}
}
array_3014.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_scatter_plot_categorically_aggregated_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ScatterPlotCategoricallyAggregatedFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3017) = &input.x_axis {
let mut array_3018 = object.key("XAxis").start_array();
for item_3019 in var_3017 {
{
#[allow(unused_mut)]
let mut object_3020 = array_3018.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_3020,
item_3019,
)?;
object_3020.finish();
}
}
array_3018.finish();
}
if let Some(var_3021) = &input.y_axis {
let mut array_3022 = object.key("YAxis").start_array();
for item_3023 in var_3021 {
{
#[allow(unused_mut)]
let mut object_3024 = array_3022.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_3024,
item_3023,
)?;
object_3024.finish();
}
}
array_3022.finish();
}
if let Some(var_3025) = &input.category {
let mut array_3026 = object.key("Category").start_array();
for item_3027 in var_3025 {
{
#[allow(unused_mut)]
let mut object_3028 = array_3026.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_3028,
item_3027,
)?;
object_3028.finish();
}
}
array_3026.finish();
}
if let Some(var_3029) = &input.size {
let mut array_3030 = object.key("Size").start_array();
for item_3031 in var_3029 {
{
#[allow(unused_mut)]
let mut object_3032 = array_3030.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_3032,
item_3031,
)?;
object_3032.finish();
}
}
array_3030.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_scatter_plot_unaggregated_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ScatterPlotUnaggregatedFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3033) = &input.x_axis {
let mut array_3034 = object.key("XAxis").start_array();
for item_3035 in var_3033 {
{
#[allow(unused_mut)]
let mut object_3036 = array_3034.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_3036,
item_3035,
)?;
object_3036.finish();
}
}
array_3034.finish();
}
if let Some(var_3037) = &input.y_axis {
let mut array_3038 = object.key("YAxis").start_array();
for item_3039 in var_3037 {
{
#[allow(unused_mut)]
let mut object_3040 = array_3038.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_3040,
item_3039,
)?;
object_3040.finish();
}
}
array_3038.finish();
}
if let Some(var_3041) = &input.size {
let mut array_3042 = object.key("Size").start_array();
for item_3043 in var_3041 {
{
#[allow(unused_mut)]
let mut object_3044 = array_3042.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_3044,
item_3043,
)?;
object_3044.finish();
}
}
array_3042.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_combo_chart_aggregated_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComboChartAggregatedFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3045) = &input.category {
let mut array_3046 = object.key("Category").start_array();
for item_3047 in var_3045 {
{
#[allow(unused_mut)]
let mut object_3048 = array_3046.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_3048,
item_3047,
)?;
object_3048.finish();
}
}
array_3046.finish();
}
if let Some(var_3049) = &input.bar_values {
let mut array_3050 = object.key("BarValues").start_array();
for item_3051 in var_3049 {
{
#[allow(unused_mut)]
let mut object_3052 = array_3050.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_3052,
item_3051,
)?;
object_3052.finish();
}
}
array_3050.finish();
}
if let Some(var_3053) = &input.colors {
let mut array_3054 = object.key("Colors").start_array();
for item_3055 in var_3053 {
{
#[allow(unused_mut)]
let mut object_3056 = array_3054.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_3056,
item_3055,
)?;
object_3056.finish();
}
}
array_3054.finish();
}
if let Some(var_3057) = &input.line_values {
let mut array_3058 = object.key("LineValues").start_array();
for item_3059 in var_3057 {
{
#[allow(unused_mut)]
let mut object_3060 = array_3058.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_3060,
item_3059,
)?;
object_3060.finish();
}
}
array_3058.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_box_plot_aggregated_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BoxPlotAggregatedFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3061) = &input.group_by {
let mut array_3062 = object.key("GroupBy").start_array();
for item_3063 in var_3061 {
{
#[allow(unused_mut)]
let mut object_3064 = array_3062.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_3064,
item_3063,
)?;
object_3064.finish();
}
}
array_3062.finish();
}
if let Some(var_3065) = &input.values {
let mut array_3066 = object.key("Values").start_array();
for item_3067 in var_3065 {
{
#[allow(unused_mut)]
let mut object_3068 = array_3066.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_3068,
item_3067,
)?;
object_3068.finish();
}
}
array_3066.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_box_plot_style_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BoxPlotStyleOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3069) = &input.fill_style {
object.key("FillStyle").string(var_3069.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_waterfall_chart_aggregated_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WaterfallChartAggregatedFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3070) = &input.categories {
let mut array_3071 = object.key("Categories").start_array();
for item_3072 in var_3070 {
{
#[allow(unused_mut)]
let mut object_3073 = array_3071.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_3073,
item_3072,
)?;
object_3073.finish();
}
}
array_3071.finish();
}
if let Some(var_3074) = &input.values {
let mut array_3075 = object.key("Values").start_array();
for item_3076 in var_3074 {
{
#[allow(unused_mut)]
let mut object_3077 = array_3075.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_3077,
item_3076,
)?;
object_3077.finish();
}
}
array_3075.finish();
}
if let Some(var_3078) = &input.breakdowns {
let mut array_3079 = object.key("Breakdowns").start_array();
for item_3080 in var_3078 {
{
#[allow(unused_mut)]
let mut object_3081 = array_3079.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_3081,
item_3080,
)?;
object_3081.finish();
}
}
array_3079.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_histogram_aggregated_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HistogramAggregatedFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3082) = &input.values {
let mut array_3083 = object.key("Values").start_array();
for item_3084 in var_3082 {
{
#[allow(unused_mut)]
let mut object_3085 = array_3083.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_3085,
item_3084,
)?;
object_3085.finish();
}
}
array_3083.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_bin_count_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BinCountOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3086) = &input.value {
object.key("Value").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3086).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_bin_width_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BinWidthOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3087) = &input.value {
object.key("Value").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_3087).into()),
);
}
if let Some(var_3088) = &input.bin_count_limit {
object.key("BinCountLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3088).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_word_cloud_aggregated_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WordCloudAggregatedFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3089) = &input.group_by {
let mut array_3090 = object.key("GroupBy").start_array();
for item_3091 in var_3089 {
{
#[allow(unused_mut)]
let mut object_3092 = array_3090.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_3092,
item_3091,
)?;
object_3092.finish();
}
}
array_3090.finish();
}
if let Some(var_3093) = &input.size {
let mut array_3094 = object.key("Size").start_array();
for item_3095 in var_3093 {
{
#[allow(unused_mut)]
let mut object_3096 = array_3094.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_3096,
item_3095,
)?;
object_3096.finish();
}
}
array_3094.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_top_bottom_ranked_computation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TopBottomRankedComputation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3097) = &input.computation_id {
object.key("ComputationId").string(var_3097.as_str());
}
if let Some(var_3098) = &input.name {
object.key("Name").string(var_3098.as_str());
}
if let Some(var_3099) = &input.category {
#[allow(unused_mut)]
let mut object_3100 = object.key("Category").start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_3100,
var_3099,
)?;
object_3100.finish();
}
if let Some(var_3101) = &input.value {
#[allow(unused_mut)]
let mut object_3102 = object.key("Value").start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(&mut object_3102, var_3101)?;
object_3102.finish();
}
if input.result_size != 0 {
object.key("ResultSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.result_size).into()),
);
}
if let Some(var_3103) = &input.r#type {
object.key("Type").string(var_3103.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_top_bottom_movers_computation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TopBottomMoversComputation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3104) = &input.computation_id {
object.key("ComputationId").string(var_3104.as_str());
}
if let Some(var_3105) = &input.name {
object.key("Name").string(var_3105.as_str());
}
if let Some(var_3106) = &input.time {
#[allow(unused_mut)]
let mut object_3107 = object.key("Time").start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_3107,
var_3106,
)?;
object_3107.finish();
}
if let Some(var_3108) = &input.category {
#[allow(unused_mut)]
let mut object_3109 = object.key("Category").start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_3109,
var_3108,
)?;
object_3109.finish();
}
if let Some(var_3110) = &input.value {
#[allow(unused_mut)]
let mut object_3111 = object.key("Value").start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(&mut object_3111, var_3110)?;
object_3111.finish();
}
if input.mover_size != 0 {
object.key("MoverSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.mover_size).into()),
);
}
if let Some(var_3112) = &input.sort_order {
object.key("SortOrder").string(var_3112.as_str());
}
if let Some(var_3113) = &input.r#type {
object.key("Type").string(var_3113.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_total_aggregation_computation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TotalAggregationComputation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3114) = &input.computation_id {
object.key("ComputationId").string(var_3114.as_str());
}
if let Some(var_3115) = &input.name {
object.key("Name").string(var_3115.as_str());
}
if let Some(var_3116) = &input.value {
#[allow(unused_mut)]
let mut object_3117 = object.key("Value").start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(&mut object_3117, var_3116)?;
object_3117.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_maximum_minimum_computation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MaximumMinimumComputation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3118) = &input.computation_id {
object.key("ComputationId").string(var_3118.as_str());
}
if let Some(var_3119) = &input.name {
object.key("Name").string(var_3119.as_str());
}
if let Some(var_3120) = &input.time {
#[allow(unused_mut)]
let mut object_3121 = object.key("Time").start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_3121,
var_3120,
)?;
object_3121.finish();
}
if let Some(var_3122) = &input.value {
#[allow(unused_mut)]
let mut object_3123 = object.key("Value").start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(&mut object_3123, var_3122)?;
object_3123.finish();
}
if let Some(var_3124) = &input.r#type {
object.key("Type").string(var_3124.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_metric_comparison_computation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MetricComparisonComputation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3125) = &input.computation_id {
object.key("ComputationId").string(var_3125.as_str());
}
if let Some(var_3126) = &input.name {
object.key("Name").string(var_3126.as_str());
}
if let Some(var_3127) = &input.time {
#[allow(unused_mut)]
let mut object_3128 = object.key("Time").start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_3128,
var_3127,
)?;
object_3128.finish();
}
if let Some(var_3129) = &input.from_value {
#[allow(unused_mut)]
let mut object_3130 = object.key("FromValue").start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(&mut object_3130, var_3129)?;
object_3130.finish();
}
if let Some(var_3131) = &input.target_value {
#[allow(unused_mut)]
let mut object_3132 = object.key("TargetValue").start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(&mut object_3132, var_3131)?;
object_3132.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_period_over_period_computation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PeriodOverPeriodComputation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3133) = &input.computation_id {
object.key("ComputationId").string(var_3133.as_str());
}
if let Some(var_3134) = &input.name {
object.key("Name").string(var_3134.as_str());
}
if let Some(var_3135) = &input.time {
#[allow(unused_mut)]
let mut object_3136 = object.key("Time").start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_3136,
var_3135,
)?;
object_3136.finish();
}
if let Some(var_3137) = &input.value {
#[allow(unused_mut)]
let mut object_3138 = object.key("Value").start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(&mut object_3138, var_3137)?;
object_3138.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_period_to_date_computation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PeriodToDateComputation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3139) = &input.computation_id {
object.key("ComputationId").string(var_3139.as_str());
}
if let Some(var_3140) = &input.name {
object.key("Name").string(var_3140.as_str());
}
if let Some(var_3141) = &input.time {
#[allow(unused_mut)]
let mut object_3142 = object.key("Time").start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_3142,
var_3141,
)?;
object_3142.finish();
}
if let Some(var_3143) = &input.value {
#[allow(unused_mut)]
let mut object_3144 = object.key("Value").start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(&mut object_3144, var_3143)?;
object_3144.finish();
}
if let Some(var_3145) = &input.period_time_granularity {
object
.key("PeriodTimeGranularity")
.string(var_3145.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_growth_rate_computation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GrowthRateComputation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3146) = &input.computation_id {
object.key("ComputationId").string(var_3146.as_str());
}
if let Some(var_3147) = &input.name {
object.key("Name").string(var_3147.as_str());
}
if let Some(var_3148) = &input.time {
#[allow(unused_mut)]
let mut object_3149 = object.key("Time").start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_3149,
var_3148,
)?;
object_3149.finish();
}
if let Some(var_3150) = &input.value {
#[allow(unused_mut)]
let mut object_3151 = object.key("Value").start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(&mut object_3151, var_3150)?;
object_3151.finish();
}
if input.period_size != 0 {
object.key("PeriodSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.period_size).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_unique_values_computation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UniqueValuesComputation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3152) = &input.computation_id {
object.key("ComputationId").string(var_3152.as_str());
}
if let Some(var_3153) = &input.name {
object.key("Name").string(var_3153.as_str());
}
if let Some(var_3154) = &input.category {
#[allow(unused_mut)]
let mut object_3155 = object.key("Category").start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_3155,
var_3154,
)?;
object_3155.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_forecast_computation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ForecastComputation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3156) = &input.computation_id {
object.key("ComputationId").string(var_3156.as_str());
}
if let Some(var_3157) = &input.name {
object.key("Name").string(var_3157.as_str());
}
if let Some(var_3158) = &input.time {
#[allow(unused_mut)]
let mut object_3159 = object.key("Time").start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_3159,
var_3158,
)?;
object_3159.finish();
}
if let Some(var_3160) = &input.value {
#[allow(unused_mut)]
let mut object_3161 = object.key("Value").start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(&mut object_3161, var_3160)?;
object_3161.finish();
}
if let Some(var_3162) = &input.periods_forward {
object.key("PeriodsForward").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3162).into()),
);
}
if let Some(var_3163) = &input.periods_backward {
object.key("PeriodsBackward").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3163).into()),
);
}
if let Some(var_3164) = &input.upper_boundary {
object.key("UpperBoundary").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_3164).into()),
);
}
if let Some(var_3165) = &input.lower_boundary {
object.key("LowerBoundary").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_3165).into()),
);
}
if let Some(var_3166) = &input.prediction_interval {
object.key("PredictionInterval").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3166).into()),
);
}
if let Some(var_3167) = &input.seasonality {
object.key("Seasonality").string(var_3167.as_str());
}
if let Some(var_3168) = &input.custom_seasonality_value {
object.key("CustomSeasonalityValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3168).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_sankey_diagram_aggregated_field_wells(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SankeyDiagramAggregatedFieldWells,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3169) = &input.source {
let mut array_3170 = object.key("Source").start_array();
for item_3171 in var_3169 {
{
#[allow(unused_mut)]
let mut object_3172 = array_3170.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_3172,
item_3171,
)?;
object_3172.finish();
}
}
array_3170.finish();
}
if let Some(var_3173) = &input.destination {
let mut array_3174 = object.key("Destination").start_array();
for item_3175 in var_3173 {
{
#[allow(unused_mut)]
let mut object_3176 = array_3174.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_field(
&mut object_3176,
item_3175,
)?;
object_3176.finish();
}
}
array_3174.finish();
}
if let Some(var_3177) = &input.weight {
let mut array_3178 = object.key("Weight").start_array();
for item_3179 in var_3177 {
{
#[allow(unused_mut)]
let mut object_3180 = array_3178.value().start_object();
crate::json_ser::serialize_structure_crate_model_measure_field(
&mut object_3180,
item_3179,
)?;
object_3180.finish();
}
}
array_3178.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_grid_layout_screen_canvas_size_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GridLayoutScreenCanvasSizeOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3181) = &input.resize_option {
object.key("ResizeOption").string(var_3181.as_str());
}
if let Some(var_3182) = &input.optimized_view_port_width {
object
.key("OptimizedViewPortWidth")
.string(var_3182.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sheet_element_rendering_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SheetElementRenderingRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3183) = &input.expression {
object.key("Expression").string(var_3183.as_str());
}
if let Some(var_3184) = &input.configuration_overrides {
#[allow(unused_mut)]
let mut object_3185 = object.key("ConfigurationOverrides").start_object();
crate::json_ser::serialize_structure_crate_model_sheet_element_configuration_overrides(
&mut object_3185,
var_3184,
)?;
object_3185.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_free_form_layout_element_border_style(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FreeFormLayoutElementBorderStyle,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3186) = &input.visibility {
object.key("Visibility").string(var_3186.as_str());
}
if let Some(var_3187) = &input.color {
object.key("Color").string(var_3187.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_free_form_layout_element_background_style(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FreeFormLayoutElementBackgroundStyle,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3188) = &input.visibility {
object.key("Visibility").string(var_3188.as_str());
}
if let Some(var_3189) = &input.color {
object.key("Color").string(var_3189.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_loading_animation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoadingAnimation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3190) = &input.visibility {
object.key("Visibility").string(var_3190.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_free_form_layout_screen_canvas_size_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FreeFormLayoutScreenCanvasSizeOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3191) = &input.optimized_view_port_width {
object
.key("OptimizedViewPortWidth")
.string(var_3191.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_section_layout_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SectionLayoutConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3192) = &input.free_form_layout {
#[allow(unused_mut)]
let mut object_3193 = object.key("FreeFormLayout").start_object();
crate::json_ser::serialize_structure_crate_model_free_form_section_layout_configuration(
&mut object_3193,
var_3192,
)?;
object_3193.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_section_style(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SectionStyle,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3194) = &input.height {
object.key("Height").string(var_3194.as_str());
}
if let Some(var_3195) = &input.padding {
#[allow(unused_mut)]
let mut object_3196 = object.key("Padding").start_object();
crate::json_ser::serialize_structure_crate_model_spacing(&mut object_3196, var_3195)?;
object_3196.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_body_section_content(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BodySectionContent,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3197) = &input.layout {
#[allow(unused_mut)]
let mut object_3198 = object.key("Layout").start_object();
crate::json_ser::serialize_structure_crate_model_section_layout_configuration(
&mut object_3198,
var_3197,
)?;
object_3198.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_section_page_break_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SectionPageBreakConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3199) = &input.after {
#[allow(unused_mut)]
let mut object_3200 = object.key("After").start_object();
crate::json_ser::serialize_structure_crate_model_section_after_page_break(
&mut object_3200,
var_3199,
)?;
object_3200.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_section_based_layout_paper_canvas_size_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SectionBasedLayoutPaperCanvasSizeOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3201) = &input.paper_size {
object.key("PaperSize").string(var_3201.as_str());
}
if let Some(var_3202) = &input.paper_orientation {
object.key("PaperOrientation").string(var_3202.as_str());
}
if let Some(var_3203) = &input.paper_margin {
#[allow(unused_mut)]
let mut object_3204 = object.key("PaperMargin").start_object();
crate::json_ser::serialize_structure_crate_model_spacing(&mut object_3204, var_3203)?;
object_3204.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_percentile_aggregation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PercentileAggregation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3205) = &input.percentile_value {
object.key("PercentileValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_3205).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_numeric_separator_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NumericSeparatorConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3206) = &input.decimal_separator {
object.key("DecimalSeparator").string(var_3206.as_str());
}
if let Some(var_3207) = &input.thousands_separator {
#[allow(unused_mut)]
let mut object_3208 = object.key("ThousandsSeparator").start_object();
crate::json_ser::serialize_structure_crate_model_thousand_separator_options(
&mut object_3208,
var_3207,
)?;
object_3208.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_decimal_places_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DecimalPlacesConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3209) = &input.decimal_places {
object.key("DecimalPlaces").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3209).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_negative_value_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NegativeValueConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3210) = &input.display_mode {
object.key("DisplayMode").string(var_3210.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_font_size(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FontSize,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3211) = &input.relative {
object.key("Relative").string(var_3211.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_font_weight(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FontWeight,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3212) = &input.name {
object.key("Name").string(var_3212.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_unaggregated_field(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UnaggregatedField,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3213) = &input.field_id {
object.key("FieldId").string(var_3213.as_str());
}
if let Some(var_3214) = &input.column {
#[allow(unused_mut)]
let mut object_3215 = object.key("Column").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_3215,
var_3214,
)?;
object_3215.finish();
}
if let Some(var_3216) = &input.format_configuration {
#[allow(unused_mut)]
let mut object_3217 = object.key("FormatConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_format_configuration(
&mut object_3217,
var_3216,
)?;
object_3217.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_field_sort(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FieldSort,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3218) = &input.field_id {
object.key("FieldId").string(var_3218.as_str());
}
if let Some(var_3219) = &input.direction {
object.key("Direction").string(var_3219.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_column_sort(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ColumnSort,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3220) = &input.sort_by {
#[allow(unused_mut)]
let mut object_3221 = object.key("SortBy").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_3221,
var_3220,
)?;
object_3221.finish();
}
if let Some(var_3222) = &input.direction {
object.key("Direction").string(var_3222.as_str());
}
if let Some(var_3223) = &input.aggregation_function {
#[allow(unused_mut)]
let mut object_3224 = object.key("AggregationFunction").start_object();
crate::json_ser::serialize_structure_crate_model_aggregation_function(
&mut object_3224,
var_3223,
)?;
object_3224.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_global_table_border_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GlobalTableBorderOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3225) = &input.uniform_border {
#[allow(unused_mut)]
let mut object_3226 = object.key("UniformBorder").start_object();
crate::json_ser::serialize_structure_crate_model_table_border_options(
&mut object_3226,
var_3225,
)?;
object_3226.finish();
}
if let Some(var_3227) = &input.side_specific_border {
#[allow(unused_mut)]
let mut object_3228 = object.key("SideSpecificBorder").start_object();
crate::json_ser::serialize_structure_crate_model_table_side_border_options(
&mut object_3228,
var_3227,
)?;
object_3228.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_table_field_url_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableFieldUrlConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3229) = &input.link_configuration {
#[allow(unused_mut)]
let mut object_3230 = object.key("LinkConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_table_field_link_configuration(
&mut object_3230,
var_3229,
)?;
object_3230.finish();
}
if let Some(var_3231) = &input.image_configuration {
#[allow(unused_mut)]
let mut object_3232 = object.key("ImageConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_table_field_image_configuration(
&mut object_3232,
var_3231,
)?;
object_3232.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_text_conditional_format(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TextConditionalFormat,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3233) = &input.background_color {
#[allow(unused_mut)]
let mut object_3234 = object.key("BackgroundColor").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_formatting_color(
&mut object_3234,
var_3233,
)?;
object_3234.finish();
}
if let Some(var_3235) = &input.text_color {
#[allow(unused_mut)]
let mut object_3236 = object.key("TextColor").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_formatting_color(
&mut object_3236,
var_3235,
)?;
object_3236.finish();
}
if let Some(var_3237) = &input.icon {
#[allow(unused_mut)]
let mut object_3238 = object.key("Icon").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_formatting_icon(
&mut object_3238,
var_3237,
)?;
object_3238.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_conditional_formatting_color(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConditionalFormattingColor,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3239) = &input.solid {
#[allow(unused_mut)]
let mut object_3240 = object.key("Solid").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_formatting_solid_color(
&mut object_3240,
var_3239,
)?;
object_3240.finish();
}
if let Some(var_3241) = &input.gradient {
#[allow(unused_mut)]
let mut object_3242 = object.key("Gradient").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_formatting_gradient_color(
&mut object_3242,
var_3241,
)?;
object_3242.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_operation_selected_fields_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterOperationSelectedFieldsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3243) = &input.selected_fields {
let mut array_3244 = object.key("SelectedFields").start_array();
for item_3245 in var_3243 {
{
array_3244.value().string(item_3245.as_str());
}
}
array_3244.finish();
}
if let Some(var_3246) = &input.selected_field_options {
object.key("SelectedFieldOptions").string(var_3246.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_operation_target_visuals_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterOperationTargetVisualsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3247) = &input.same_sheet_target_visual_configuration {
#[allow(unused_mut)]
let mut object_3248 = object
.key("SameSheetTargetVisualConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_same_sheet_target_visual_configuration(
&mut object_3248,
var_3247,
)?;
object_3248.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_local_navigation_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LocalNavigationConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3249) = &input.target_sheet_id {
object.key("TargetSheetId").string(var_3249.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_set_parameter_value_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SetParameterValueConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3250) = &input.destination_parameter_name {
object
.key("DestinationParameterName")
.string(var_3250.as_str());
}
if let Some(var_3251) = &input.value {
#[allow(unused_mut)]
let mut object_3252 = object.key("Value").start_object();
crate::json_ser::serialize_structure_crate_model_destination_parameter_value_configuration(
&mut object_3252,
var_3251,
)?;
object_3252.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pivot_table_sort_by(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PivotTableSortBy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3253) = &input.field {
#[allow(unused_mut)]
let mut object_3254 = object.key("Field").start_object();
crate::json_ser::serialize_structure_crate_model_field_sort(&mut object_3254, var_3253)?;
object_3254.finish();
}
if let Some(var_3255) = &input.column {
#[allow(unused_mut)]
let mut object_3256 = object.key("Column").start_object();
crate::json_ser::serialize_structure_crate_model_column_sort(&mut object_3256, var_3255)?;
object_3256.finish();
}
if let Some(var_3257) = &input.data_path {
#[allow(unused_mut)]
let mut object_3258 = object.key("DataPath").start_object();
crate::json_ser::serialize_structure_crate_model_data_path_sort(
&mut object_3258,
var_3257,
)?;
object_3258.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pivot_table_field_subtotal_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PivotTableFieldSubtotalOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3259) = &input.field_id {
object.key("FieldId").string(var_3259.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_data_path_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataPathValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3260) = &input.field_id {
object.key("FieldId").string(var_3260.as_str());
}
if let Some(var_3261) = &input.field_value {
object.key("FieldValue").string(var_3261.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_pivot_table_conditional_formatting_scope(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PivotTableConditionalFormattingScope,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3262) = &input.role {
object.key("Role").string(var_3262.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_panel_title_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PanelTitleOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3263) = &input.visibility {
object.key("Visibility").string(var_3263.as_str());
}
if let Some(var_3264) = &input.font_configuration {
#[allow(unused_mut)]
let mut object_3265 = object.key("FontConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_font_configuration(
&mut object_3265,
var_3264,
)?;
object_3265.finish();
}
if let Some(var_3266) = &input.horizontal_text_alignment {
object
.key("HorizontalTextAlignment")
.string(var_3266.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_numeric_axis_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NumericAxisOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3267) = &input.scale {
#[allow(unused_mut)]
let mut object_3268 = object.key("Scale").start_object();
crate::json_ser::serialize_structure_crate_model_axis_scale(&mut object_3268, var_3267)?;
object_3268.finish();
}
if let Some(var_3269) = &input.range {
#[allow(unused_mut)]
let mut object_3270 = object.key("Range").start_object();
crate::json_ser::serialize_structure_crate_model_axis_display_range(
&mut object_3270,
var_3269,
)?;
object_3270.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_date_axis_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DateAxisOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3271) = &input.missing_date_visibility {
object
.key("MissingDateVisibility")
.string(var_3271.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_visible_range_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VisibleRangeOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3272) = &input.percent_range {
#[allow(unused_mut)]
let mut object_3273 = object.key("PercentRange").start_object();
crate::json_ser::serialize_structure_crate_model_percent_visible_range(
&mut object_3273,
var_3272,
)?;
object_3273.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_axis_label_reference_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AxisLabelReferenceOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3274) = &input.field_id {
object.key("FieldId").string(var_3274.as_str());
}
if let Some(var_3275) = &input.column {
#[allow(unused_mut)]
let mut object_3276 = object.key("Column").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_3276,
var_3275,
)?;
object_3276.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_field_label_type(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FieldLabelType,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3277) = &input.field_id {
object.key("FieldId").string(var_3277.as_str());
}
if let Some(var_3278) = &input.visibility {
object.key("Visibility").string(var_3278.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_data_path_label_type(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataPathLabelType,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3279) = &input.field_id {
object.key("FieldId").string(var_3279.as_str());
}
if let Some(var_3280) = &input.field_value {
object.key("FieldValue").string(var_3280.as_str());
}
if let Some(var_3281) = &input.visibility {
object.key("Visibility").string(var_3281.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_range_ends_label_type(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RangeEndsLabelType,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3282) = &input.visibility {
object.key("Visibility").string(var_3282.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_minimum_label_type(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MinimumLabelType,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3283) = &input.visibility {
object.key("Visibility").string(var_3283.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_maximum_label_type(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MaximumLabelType,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3284) = &input.visibility {
object.key("Visibility").string(var_3284.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tooltip_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TooltipItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3285) = &input.field_tooltip_item {
#[allow(unused_mut)]
let mut object_3286 = object.key("FieldTooltipItem").start_object();
crate::json_ser::serialize_structure_crate_model_field_tooltip_item(
&mut object_3286,
var_3285,
)?;
object_3286.finish();
}
if let Some(var_3287) = &input.column_tooltip_item {
#[allow(unused_mut)]
let mut object_3288 = object.key("ColumnTooltipItem").start_object();
crate::json_ser::serialize_structure_crate_model_column_tooltip_item(
&mut object_3288,
var_3287,
)?;
object_3288.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_reference_line_static_data_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReferenceLineStaticDataConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("Value").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.value).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_reference_line_dynamic_data_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReferenceLineDynamicDataConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3289) = &input.column {
#[allow(unused_mut)]
let mut object_3290 = object.key("Column").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_3290,
var_3289,
)?;
object_3290.finish();
}
if let Some(var_3291) = &input.measure_aggregation_function {
#[allow(unused_mut)]
let mut object_3292 = object.key("MeasureAggregationFunction").start_object();
crate::json_ser::serialize_structure_crate_model_aggregation_function(
&mut object_3292,
var_3291,
)?;
object_3292.finish();
}
if let Some(var_3293) = &input.calculation {
#[allow(unused_mut)]
let mut object_3294 = object.key("Calculation").start_object();
crate::json_ser::serialize_structure_crate_model_numerical_aggregation_function(
&mut object_3294,
var_3293,
)?;
object_3294.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_reference_line_value_label_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReferenceLineValueLabelConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3295) = &input.relative_position {
object.key("RelativePosition").string(var_3295.as_str());
}
if let Some(var_3296) = &input.format_configuration {
#[allow(unused_mut)]
let mut object_3297 = object.key("FormatConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_numeric_format_configuration(
&mut object_3297,
var_3296,
)?;
object_3297.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_reference_line_custom_label_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReferenceLineCustomLabelConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3298) = &input.custom_label {
object.key("CustomLabel").string(var_3298.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_numeric_equality_drill_down_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NumericEqualityDrillDownFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3299) = &input.column {
#[allow(unused_mut)]
let mut object_3300 = object.key("Column").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_3300,
var_3299,
)?;
object_3300.finish();
}
{
object.key("Value").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.value).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_category_drill_down_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CategoryDrillDownFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3301) = &input.column {
#[allow(unused_mut)]
let mut object_3302 = object.key("Column").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_3302,
var_3301,
)?;
object_3302.finish();
}
if let Some(var_3303) = &input.category_values {
let mut array_3304 = object.key("CategoryValues").start_array();
for item_3305 in var_3303 {
{
array_3304.value().string(item_3305.as_str());
}
}
array_3304.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_time_range_drill_down_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimeRangeDrillDownFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3306) = &input.column {
#[allow(unused_mut)]
let mut object_3307 = object.key("Column").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_3307,
var_3306,
)?;
object_3307.finish();
}
if let Some(var_3308) = &input.range_minimum {
object
.key("RangeMinimum")
.date_time(var_3308, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_3309) = &input.range_maximum {
object
.key("RangeMaximum")
.date_time(var_3309, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_3310) = &input.time_granularity {
object.key("TimeGranularity").string(var_3310.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_numerical_measure_field(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NumericalMeasureField,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3311) = &input.field_id {
object.key("FieldId").string(var_3311.as_str());
}
if let Some(var_3312) = &input.column {
#[allow(unused_mut)]
let mut object_3313 = object.key("Column").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_3313,
var_3312,
)?;
object_3313.finish();
}
if let Some(var_3314) = &input.aggregation_function {
#[allow(unused_mut)]
let mut object_3315 = object.key("AggregationFunction").start_object();
crate::json_ser::serialize_structure_crate_model_numerical_aggregation_function(
&mut object_3315,
var_3314,
)?;
object_3315.finish();
}
if let Some(var_3316) = &input.format_configuration {
#[allow(unused_mut)]
let mut object_3317 = object.key("FormatConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_number_format_configuration(
&mut object_3317,
var_3316,
)?;
object_3317.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_categorical_measure_field(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CategoricalMeasureField,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3318) = &input.field_id {
object.key("FieldId").string(var_3318.as_str());
}
if let Some(var_3319) = &input.column {
#[allow(unused_mut)]
let mut object_3320 = object.key("Column").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_3320,
var_3319,
)?;
object_3320.finish();
}
if let Some(var_3321) = &input.aggregation_function {
object.key("AggregationFunction").string(var_3321.as_str());
}
if let Some(var_3322) = &input.format_configuration {
#[allow(unused_mut)]
let mut object_3323 = object.key("FormatConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_string_format_configuration(
&mut object_3323,
var_3322,
)?;
object_3323.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_date_measure_field(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DateMeasureField,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3324) = &input.field_id {
object.key("FieldId").string(var_3324.as_str());
}
if let Some(var_3325) = &input.column {
#[allow(unused_mut)]
let mut object_3326 = object.key("Column").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_3326,
var_3325,
)?;
object_3326.finish();
}
if let Some(var_3327) = &input.aggregation_function {
object.key("AggregationFunction").string(var_3327.as_str());
}
if let Some(var_3328) = &input.format_configuration {
#[allow(unused_mut)]
let mut object_3329 = object.key("FormatConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_date_time_format_configuration(
&mut object_3329,
var_3328,
)?;
object_3329.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_calculated_measure_field(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CalculatedMeasureField,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3330) = &input.field_id {
object.key("FieldId").string(var_3330.as_str());
}
if let Some(var_3331) = &input.expression {
object.key("Expression").string(var_3331.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_numerical_dimension_field(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NumericalDimensionField,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3332) = &input.field_id {
object.key("FieldId").string(var_3332.as_str());
}
if let Some(var_3333) = &input.column {
#[allow(unused_mut)]
let mut object_3334 = object.key("Column").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_3334,
var_3333,
)?;
object_3334.finish();
}
if let Some(var_3335) = &input.hierarchy_id {
object.key("HierarchyId").string(var_3335.as_str());
}
if let Some(var_3336) = &input.format_configuration {
#[allow(unused_mut)]
let mut object_3337 = object.key("FormatConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_number_format_configuration(
&mut object_3337,
var_3336,
)?;
object_3337.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_categorical_dimension_field(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CategoricalDimensionField,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3338) = &input.field_id {
object.key("FieldId").string(var_3338.as_str());
}
if let Some(var_3339) = &input.column {
#[allow(unused_mut)]
let mut object_3340 = object.key("Column").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_3340,
var_3339,
)?;
object_3340.finish();
}
if let Some(var_3341) = &input.hierarchy_id {
object.key("HierarchyId").string(var_3341.as_str());
}
if let Some(var_3342) = &input.format_configuration {
#[allow(unused_mut)]
let mut object_3343 = object.key("FormatConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_string_format_configuration(
&mut object_3343,
var_3342,
)?;
object_3343.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_date_dimension_field(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DateDimensionField,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3344) = &input.field_id {
object.key("FieldId").string(var_3344.as_str());
}
if let Some(var_3345) = &input.column {
#[allow(unused_mut)]
let mut object_3346 = object.key("Column").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_3346,
var_3345,
)?;
object_3346.finish();
}
if let Some(var_3347) = &input.date_granularity {
object.key("DateGranularity").string(var_3347.as_str());
}
if let Some(var_3348) = &input.hierarchy_id {
object.key("HierarchyId").string(var_3348.as_str());
}
if let Some(var_3349) = &input.format_configuration {
#[allow(unused_mut)]
let mut object_3350 = object.key("FormatConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_date_time_format_configuration(
&mut object_3350,
var_3349,
)?;
object_3350.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_comparison_format_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComparisonFormatConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3351) = &input.number_display_format_configuration {
#[allow(unused_mut)]
let mut object_3352 = object
.key("NumberDisplayFormatConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_number_display_format_configuration(
&mut object_3352,
var_3351,
)?;
object_3352.finish();
}
if let Some(var_3353) = &input.percentage_display_format_configuration {
#[allow(unused_mut)]
let mut object_3354 = object
.key("PercentageDisplayFormatConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_percentage_display_format_configuration(
&mut object_3354,
var_3353,
)?;
object_3354.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_conditional_formatting_icon(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConditionalFormattingIcon,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3355) = &input.icon_set {
#[allow(unused_mut)]
let mut object_3356 = object.key("IconSet").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_formatting_icon_set(
&mut object_3356,
var_3355,
)?;
object_3356.finish();
}
if let Some(var_3357) = &input.custom_condition {
#[allow(unused_mut)]
let mut object_3358 = object.key("CustomCondition").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_formatting_custom_icon_condition(&mut object_3358, var_3357)?;
object_3358.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_arc_axis_display_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ArcAxisDisplayRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3359) = &input.min {
object.key("Min").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_3359).into()),
);
}
if let Some(var_3360) = &input.max {
object.key("Max").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_3360).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_what_if_point_scenario(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WhatIfPointScenario,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3361) = &input.date {
object
.key("Date")
.date_time(var_3361, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
{
object.key("Value").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.value).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_what_if_range_scenario(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WhatIfRangeScenario,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3362) = &input.start_date {
object
.key("StartDate")
.date_time(var_3362, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_3363) = &input.end_date {
object
.key("EndDate")
.date_time(var_3363, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
{
object.key("Value").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.value).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_line_chart_series_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LineChartSeriesSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3364) = &input.line_style_settings {
#[allow(unused_mut)]
let mut object_3365 = object.key("LineStyleSettings").start_object();
crate::json_ser::serialize_structure_crate_model_line_chart_line_style_settings(
&mut object_3365,
var_3364,
)?;
object_3365.finish();
}
if let Some(var_3366) = &input.marker_style_settings {
#[allow(unused_mut)]
let mut object_3367 = object.key("MarkerStyleSettings").start_object();
crate::json_ser::serialize_structure_crate_model_line_chart_marker_style_settings(
&mut object_3367,
var_3366,
)?;
object_3367.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_cluster_marker(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ClusterMarker,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3368) = &input.simple_cluster_marker {
#[allow(unused_mut)]
let mut object_3369 = object.key("SimpleClusterMarker").start_object();
crate::json_ser::serialize_structure_crate_model_simple_cluster_marker(
&mut object_3369,
var_3368,
)?;
object_3369.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_shape_conditional_format(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ShapeConditionalFormat,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3370) = &input.background_color {
#[allow(unused_mut)]
let mut object_3371 = object.key("BackgroundColor").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_formatting_color(
&mut object_3371,
var_3370,
)?;
object_3371.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sheet_element_configuration_overrides(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SheetElementConfigurationOverrides,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3372) = &input.visibility {
object.key("Visibility").string(var_3372.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_free_form_section_layout_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FreeFormSectionLayoutConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3373) = &input.elements {
let mut array_3374 = object.key("Elements").start_array();
for item_3375 in var_3373 {
{
#[allow(unused_mut)]
let mut object_3376 = array_3374.value().start_object();
crate::json_ser::serialize_structure_crate_model_free_form_layout_element(
&mut object_3376,
item_3375,
)?;
object_3376.finish();
}
}
array_3374.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_spacing(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Spacing,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3377) = &input.top {
object.key("Top").string(var_3377.as_str());
}
if let Some(var_3378) = &input.bottom {
object.key("Bottom").string(var_3378.as_str());
}
if let Some(var_3379) = &input.left {
object.key("Left").string(var_3379.as_str());
}
if let Some(var_3380) = &input.right {
object.key("Right").string(var_3380.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_section_after_page_break(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SectionAfterPageBreak,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3381) = &input.status {
object.key("Status").string(var_3381.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_thousand_separator_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ThousandSeparatorOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3382) = &input.symbol {
object.key("Symbol").string(var_3382.as_str());
}
if let Some(var_3383) = &input.visibility {
object.key("Visibility").string(var_3383.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_table_border_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableBorderOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3384) = &input.color {
object.key("Color").string(var_3384.as_str());
}
if let Some(var_3385) = &input.thickness {
object.key("Thickness").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3385).into()),
);
}
if let Some(var_3386) = &input.style {
object.key("Style").string(var_3386.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_table_side_border_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableSideBorderOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3387) = &input.inner_vertical {
#[allow(unused_mut)]
let mut object_3388 = object.key("InnerVertical").start_object();
crate::json_ser::serialize_structure_crate_model_table_border_options(
&mut object_3388,
var_3387,
)?;
object_3388.finish();
}
if let Some(var_3389) = &input.inner_horizontal {
#[allow(unused_mut)]
let mut object_3390 = object.key("InnerHorizontal").start_object();
crate::json_ser::serialize_structure_crate_model_table_border_options(
&mut object_3390,
var_3389,
)?;
object_3390.finish();
}
if let Some(var_3391) = &input.left {
#[allow(unused_mut)]
let mut object_3392 = object.key("Left").start_object();
crate::json_ser::serialize_structure_crate_model_table_border_options(
&mut object_3392,
var_3391,
)?;
object_3392.finish();
}
if let Some(var_3393) = &input.right {
#[allow(unused_mut)]
let mut object_3394 = object.key("Right").start_object();
crate::json_ser::serialize_structure_crate_model_table_border_options(
&mut object_3394,
var_3393,
)?;
object_3394.finish();
}
if let Some(var_3395) = &input.top {
#[allow(unused_mut)]
let mut object_3396 = object.key("Top").start_object();
crate::json_ser::serialize_structure_crate_model_table_border_options(
&mut object_3396,
var_3395,
)?;
object_3396.finish();
}
if let Some(var_3397) = &input.bottom {
#[allow(unused_mut)]
let mut object_3398 = object.key("Bottom").start_object();
crate::json_ser::serialize_structure_crate_model_table_border_options(
&mut object_3398,
var_3397,
)?;
object_3398.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_table_field_link_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableFieldLinkConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3399) = &input.target {
object.key("Target").string(var_3399.as_str());
}
if let Some(var_3400) = &input.content {
#[allow(unused_mut)]
let mut object_3401 = object.key("Content").start_object();
crate::json_ser::serialize_structure_crate_model_table_field_link_content_configuration(
&mut object_3401,
var_3400,
)?;
object_3401.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_table_field_image_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableFieldImageConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3402) = &input.sizing_options {
#[allow(unused_mut)]
let mut object_3403 = object.key("SizingOptions").start_object();
crate::json_ser::serialize_structure_crate_model_table_cell_image_sizing_configuration(
&mut object_3403,
var_3402,
)?;
object_3403.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_conditional_formatting_solid_color(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConditionalFormattingSolidColor,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3404) = &input.expression {
object.key("Expression").string(var_3404.as_str());
}
if let Some(var_3405) = &input.color {
object.key("Color").string(var_3405.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_conditional_formatting_gradient_color(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConditionalFormattingGradientColor,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3406) = &input.expression {
object.key("Expression").string(var_3406.as_str());
}
if let Some(var_3407) = &input.color {
#[allow(unused_mut)]
let mut object_3408 = object.key("Color").start_object();
crate::json_ser::serialize_structure_crate_model_gradient_color(
&mut object_3408,
var_3407,
)?;
object_3408.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_same_sheet_target_visual_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SameSheetTargetVisualConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3409) = &input.target_visuals {
let mut array_3410 = object.key("TargetVisuals").start_array();
for item_3411 in var_3409 {
{
array_3410.value().string(item_3411.as_str());
}
}
array_3410.finish();
}
if let Some(var_3412) = &input.target_visual_options {
object.key("TargetVisualOptions").string(var_3412.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_destination_parameter_value_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DestinationParameterValueConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3413) = &input.custom_values_configuration {
#[allow(unused_mut)]
let mut object_3414 = object.key("CustomValuesConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_custom_values_configuration(
&mut object_3414,
var_3413,
)?;
object_3414.finish();
}
if let Some(var_3415) = &input.select_all_value_options {
object
.key("SelectAllValueOptions")
.string(var_3415.as_str());
}
if let Some(var_3416) = &input.source_parameter_name {
object.key("SourceParameterName").string(var_3416.as_str());
}
if let Some(var_3417) = &input.source_field {
object.key("SourceField").string(var_3417.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_data_path_sort(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataPathSort,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3418) = &input.direction {
object.key("Direction").string(var_3418.as_str());
}
if let Some(var_3419) = &input.sort_paths {
let mut array_3420 = object.key("SortPaths").start_array();
for item_3421 in var_3419 {
{
#[allow(unused_mut)]
let mut object_3422 = array_3420.value().start_object();
crate::json_ser::serialize_structure_crate_model_data_path_value(
&mut object_3422,
item_3421,
)?;
object_3422.finish();
}
}
array_3420.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_axis_scale(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AxisScale,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3423) = &input.linear {
#[allow(unused_mut)]
let mut object_3424 = object.key("Linear").start_object();
crate::json_ser::serialize_structure_crate_model_axis_linear_scale(
&mut object_3424,
var_3423,
)?;
object_3424.finish();
}
if let Some(var_3425) = &input.logarithmic {
#[allow(unused_mut)]
let mut object_3426 = object.key("Logarithmic").start_object();
crate::json_ser::serialize_structure_crate_model_axis_logarithmic_scale(
&mut object_3426,
var_3425,
)?;
object_3426.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_axis_display_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AxisDisplayRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3427) = &input.min_max {
#[allow(unused_mut)]
let mut object_3428 = object.key("MinMax").start_object();
crate::json_ser::serialize_structure_crate_model_axis_display_min_max_range(
&mut object_3428,
var_3427,
)?;
object_3428.finish();
}
if let Some(var_3429) = &input.data_driven {
#[allow(unused_mut)]
let mut object_3430 = object.key("DataDriven").start_object();
crate::json_ser::serialize_structure_crate_model_axis_display_data_driven_range(
&mut object_3430,
var_3429,
)?;
object_3430.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_percent_visible_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PercentVisibleRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3431) = &input.from {
object.key("From").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_3431).into()),
);
}
if let Some(var_3432) = &input.to {
object.key("To").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_3432).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_field_tooltip_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FieldTooltipItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3433) = &input.field_id {
object.key("FieldId").string(var_3433.as_str());
}
if let Some(var_3434) = &input.label {
object.key("Label").string(var_3434.as_str());
}
if let Some(var_3435) = &input.visibility {
object.key("Visibility").string(var_3435.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_column_tooltip_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ColumnTooltipItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3436) = &input.column {
#[allow(unused_mut)]
let mut object_3437 = object.key("Column").start_object();
crate::json_ser::serialize_structure_crate_model_column_identifier(
&mut object_3437,
var_3436,
)?;
object_3437.finish();
}
if let Some(var_3438) = &input.label {
object.key("Label").string(var_3438.as_str());
}
if let Some(var_3439) = &input.visibility {
object.key("Visibility").string(var_3439.as_str());
}
if let Some(var_3440) = &input.aggregation {
#[allow(unused_mut)]
let mut object_3441 = object.key("Aggregation").start_object();
crate::json_ser::serialize_structure_crate_model_aggregation_function(
&mut object_3441,
var_3440,
)?;
object_3441.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_conditional_formatting_icon_set(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConditionalFormattingIconSet,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3442) = &input.expression {
object.key("Expression").string(var_3442.as_str());
}
if let Some(var_3443) = &input.icon_set_type {
object.key("IconSetType").string(var_3443.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_conditional_formatting_custom_icon_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConditionalFormattingCustomIconCondition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3444) = &input.expression {
object.key("Expression").string(var_3444.as_str());
}
if let Some(var_3445) = &input.icon_options {
#[allow(unused_mut)]
let mut object_3446 = object.key("IconOptions").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_formatting_custom_icon_options(&mut object_3446, var_3445)?;
object_3446.finish();
}
if let Some(var_3447) = &input.color {
object.key("Color").string(var_3447.as_str());
}
if let Some(var_3448) = &input.display_configuration {
#[allow(unused_mut)]
let mut object_3449 = object.key("DisplayConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_formatting_icon_display_configuration(&mut object_3449, var_3448)?;
object_3449.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_simple_cluster_marker(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SimpleClusterMarker,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3450) = &input.color {
object.key("Color").string(var_3450.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_table_field_link_content_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableFieldLinkContentConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3451) = &input.custom_text_content {
#[allow(unused_mut)]
let mut object_3452 = object.key("CustomTextContent").start_object();
crate::json_ser::serialize_structure_crate_model_table_field_custom_text_content(
&mut object_3452,
var_3451,
)?;
object_3452.finish();
}
if let Some(var_3453) = &input.custom_icon_content {
#[allow(unused_mut)]
let mut object_3454 = object.key("CustomIconContent").start_object();
crate::json_ser::serialize_structure_crate_model_table_field_custom_icon_content(
&mut object_3454,
var_3453,
)?;
object_3454.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_table_cell_image_sizing_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableCellImageSizingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3455) = &input.table_cell_image_scaling_configuration {
object
.key("TableCellImageScalingConfiguration")
.string(var_3455.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_gradient_color(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GradientColor,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3456) = &input.stops {
let mut array_3457 = object.key("Stops").start_array();
for item_3458 in var_3456 {
{
#[allow(unused_mut)]
let mut object_3459 = array_3457.value().start_object();
crate::json_ser::serialize_structure_crate_model_gradient_stop(
&mut object_3459,
item_3458,
)?;
object_3459.finish();
}
}
array_3457.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_values_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomValuesConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3460) = &input.include_null_value {
object.key("IncludeNullValue").boolean(*var_3460);
}
if let Some(var_3461) = &input.custom_values {
#[allow(unused_mut)]
let mut object_3462 = object.key("CustomValues").start_object();
crate::json_ser::serialize_structure_crate_model_custom_parameter_values(
&mut object_3462,
var_3461,
)?;
object_3462.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_axis_linear_scale(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AxisLinearScale,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3463) = &input.step_count {
object.key("StepCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3463).into()),
);
}
if let Some(var_3464) = &input.step_size {
object.key("StepSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_3464).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_axis_logarithmic_scale(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AxisLogarithmicScale,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3465) = &input.base {
object.key("Base").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_3465).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_axis_display_min_max_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AxisDisplayMinMaxRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3466) = &input.minimum {
object.key("Minimum").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_3466).into()),
);
}
if let Some(var_3467) = &input.maximum {
object.key("Maximum").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_3467).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_axis_display_data_driven_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AxisDisplayDataDrivenRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
let (_, _) = (object, input);
Ok(())
}
pub fn serialize_structure_crate_model_conditional_formatting_custom_icon_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConditionalFormattingCustomIconOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3468) = &input.icon {
object.key("Icon").string(var_3468.as_str());
}
if let Some(var_3469) = &input.unicode_icon {
object.key("UnicodeIcon").string(var_3469.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_conditional_formatting_icon_display_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConditionalFormattingIconDisplayConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3470) = &input.icon_display_option {
object.key("IconDisplayOption").string(var_3470.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_table_field_custom_text_content(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableFieldCustomTextContent,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3471) = &input.value {
object.key("Value").string(var_3471.as_str());
}
if let Some(var_3472) = &input.font_configuration {
#[allow(unused_mut)]
let mut object_3473 = object.key("FontConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_font_configuration(
&mut object_3473,
var_3472,
)?;
object_3473.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_table_field_custom_icon_content(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableFieldCustomIconContent,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3474) = &input.icon {
object.key("Icon").string(var_3474.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_gradient_stop(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GradientStop,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("GradientOffset").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.gradient_offset).into()),
);
}
if let Some(var_3475) = &input.data_value {
object.key("DataValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_3475).into()),
);
}
if let Some(var_3476) = &input.color {
object.key("Color").string(var_3476.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_parameter_values(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomParameterValues,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3477) = &input.string_values {
let mut array_3478 = object.key("StringValues").start_array();
for item_3479 in var_3477 {
{
array_3478.value().string(item_3479.as_str());
}
}
array_3478.finish();
}
if let Some(var_3480) = &input.integer_values {
let mut array_3481 = object.key("IntegerValues").start_array();
for item_3482 in var_3480 {
{
array_3481.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*item_3482).into()),
);
}
}
array_3481.finish();
}
if let Some(var_3483) = &input.decimal_values {
let mut array_3484 = object.key("DecimalValues").start_array();
for item_3485 in var_3483 {
{
array_3484.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*item_3485).into()),
);
}
}
array_3484.finish();
}
if let Some(var_3486) = &input.date_time_values {
let mut array_3487 = object.key("DateTimeValues").start_array();
for item_3488 in var_3486 {
{
array_3487
.value()
.date_time(item_3488, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
}
array_3487.finish();
}
Ok(())
}