pub fn serialize_structure_crate_input_create_aws_log_source_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAwsLogSourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.enable_all_dimensions {
#[allow(unused_mut)]
let mut object_2 = object.key("enableAllDimensions").start_object();
for (key_3, value_4) in var_1 {
{
#[allow(unused_mut)]
let mut object_5 = object_2.key(key_3.as_str()).start_object();
for (key_6, value_7) in value_4 {
{
let mut array_8 = object_5.key(key_6.as_str()).start_array();
for item_9 in value_7 {
{
array_8.value().string(item_9.as_str());
}
}
array_8.finish();
}
}
object_5.finish();
}
}
object_2.finish();
}
if let Some(var_10) = &input.enable_single_dimension {
let mut array_11 = object.key("enableSingleDimension").start_array();
for item_12 in var_10 {
{
array_11.value().string(item_12.as_str());
}
}
array_11.finish();
}
if let Some(var_13) = &input.enable_two_dimensions {
#[allow(unused_mut)]
let mut object_14 = object.key("enableTwoDimensions").start_object();
for (key_15, value_16) in var_13 {
{
let mut array_17 = object_14.key(key_15.as_str()).start_array();
for item_18 in value_16 {
{
array_17.value().string(item_18.as_str());
}
}
array_17.finish();
}
}
object_14.finish();
}
if let Some(var_19) = &input.input_order {
let mut array_20 = object.key("inputOrder").start_array();
for item_21 in var_19 {
{
array_20.value().string(item_21.as_str());
}
}
array_20.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_custom_log_source_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateCustomLogSourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_22) = &input.custom_source_name {
object.key("customSourceName").string(var_22.as_str());
}
if let Some(var_23) = &input.event_class {
object.key("eventClass").string(var_23.as_str());
}
if let Some(var_24) = &input.glue_invocation_role_arn {
object.key("glueInvocationRoleArn").string(var_24.as_str());
}
if let Some(var_25) = &input.log_provider_account_id {
object.key("logProviderAccountId").string(var_25.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_datalake_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDatalakeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_26) = &input.configurations {
#[allow(unused_mut)]
let mut object_27 = object.key("configurations").start_object();
for (key_28, value_29) in var_26 {
{
#[allow(unused_mut)]
let mut object_30 = object_27.key(key_28.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_lake_configuration_request(
&mut object_30,
value_29,
)?;
object_30.finish();
}
}
object_27.finish();
}
if let Some(var_31) = &input.enable_all {
object.key("enableAll").boolean(*var_31);
}
if let Some(var_32) = &input.meta_store_manager_role_arn {
object
.key("metaStoreManagerRoleArn")
.string(var_32.as_str());
}
if let Some(var_33) = &input.regions {
let mut array_34 = object.key("regions").start_array();
for item_35 in var_33 {
{
array_34.value().string(item_35.as_str());
}
}
array_34.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_datalake_auto_enable_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDatalakeAutoEnableInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_36) = &input.configuration_for_new_accounts {
let mut array_37 = object.key("configurationForNewAccounts").start_array();
for item_38 in var_36 {
{
#[allow(unused_mut)]
let mut object_39 = array_37.value().start_object();
crate::json_ser::serialize_structure_crate_model_auto_enable_new_region_configuration(&mut object_39, item_38)?;
object_39.finish();
}
}
array_37.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_datalake_delegated_admin_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDatalakeDelegatedAdminInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_40) = &input.account {
object.key("account").string(var_40.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_datalake_exceptions_subscription_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDatalakeExceptionsSubscriptionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_41) = &input.notification_endpoint {
object.key("notificationEndpoint").string(var_41.as_str());
}
if let Some(var_42) = &input.subscription_protocol {
object.key("subscriptionProtocol").string(var_42.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_subscriber_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSubscriberInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_43) = &input.access_types {
let mut array_44 = object.key("accessTypes").start_array();
for item_45 in var_43 {
{
array_44.value().string(item_45.as_str());
}
}
array_44.finish();
}
if let Some(var_46) = &input.account_id {
object.key("accountId").string(var_46.as_str());
}
if let Some(var_47) = &input.external_id {
object.key("externalId").string(var_47.as_str());
}
if let Some(var_48) = &input.source_types {
let mut array_49 = object.key("sourceTypes").start_array();
for item_50 in var_48 {
{
#[allow(unused_mut)]
let mut object_51 = array_49.value().start_object();
crate::json_ser::serialize_union_crate_model_source_type(&mut object_51, item_50)?;
object_51.finish();
}
}
array_49.finish();
}
if let Some(var_52) = &input.subscriber_description {
object.key("subscriberDescription").string(var_52.as_str());
}
if let Some(var_53) = &input.subscriber_name {
object.key("subscriberName").string(var_53.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_subscription_notification_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSubscriptionNotificationConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_54) = &input.create_sqs {
object.key("createSqs").boolean(*var_54);
}
if let Some(var_55) = &input.https_api_key_name {
object.key("httpsApiKeyName").string(var_55.as_str());
}
if let Some(var_56) = &input.https_api_key_value {
object.key("httpsApiKeyValue").string(var_56.as_str());
}
if let Some(var_57) = &input.https_method {
object.key("httpsMethod").string(var_57.as_str());
}
if let Some(var_58) = &input.role_arn {
object.key("roleArn").string(var_58.as_str());
}
if let Some(var_59) = &input.subscription_endpoint {
object.key("subscriptionEndpoint").string(var_59.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_aws_log_source_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAwsLogSourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_60) = &input.disable_all_dimensions {
#[allow(unused_mut)]
let mut object_61 = object.key("disableAllDimensions").start_object();
for (key_62, value_63) in var_60 {
{
#[allow(unused_mut)]
let mut object_64 = object_61.key(key_62.as_str()).start_object();
for (key_65, value_66) in value_63 {
{
let mut array_67 = object_64.key(key_65.as_str()).start_array();
for item_68 in value_66 {
{
array_67.value().string(item_68.as_str());
}
}
array_67.finish();
}
}
object_64.finish();
}
}
object_61.finish();
}
if let Some(var_69) = &input.disable_single_dimension {
let mut array_70 = object.key("disableSingleDimension").start_array();
for item_71 in var_69 {
{
array_70.value().string(item_71.as_str());
}
}
array_70.finish();
}
if let Some(var_72) = &input.disable_two_dimensions {
#[allow(unused_mut)]
let mut object_73 = object.key("disableTwoDimensions").start_object();
for (key_74, value_75) in var_72 {
{
let mut array_76 = object_73.key(key_74.as_str()).start_array();
for item_77 in value_75 {
{
array_76.value().string(item_77.as_str());
}
}
array_76.finish();
}
}
object_73.finish();
}
if let Some(var_78) = &input.input_order {
let mut array_79 = object.key("inputOrder").start_array();
for item_80 in var_78 {
{
array_79.value().string(item_80.as_str());
}
}
array_79.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_datalake_auto_enable_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteDatalakeAutoEnableInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_81) = &input.remove_from_configuration_for_new_accounts {
let mut array_82 = object
.key("removeFromConfigurationForNewAccounts")
.start_array();
for item_83 in var_81 {
{
#[allow(unused_mut)]
let mut object_84 = array_82.value().start_object();
crate::json_ser::serialize_structure_crate_model_auto_enable_new_region_configuration(&mut object_84, item_83)?;
object_84.finish();
}
}
array_82.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_datalake_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetDatalakeStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.account_set {
let mut array_86 = object.key("accountSet").start_array();
for item_87 in var_85 {
{
array_86.value().string(item_87.as_str());
}
}
array_86.finish();
}
if let Some(var_88) = &input.max_account_results {
object.key("maxAccountResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_88).into()),
);
}
if let Some(var_89) = &input.next_token {
object.key("nextToken").string(var_89.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_datalake_exceptions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDatalakeExceptionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_90) = &input.max_failures {
object.key("maxFailures").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_90).into()),
);
}
if let Some(var_91) = &input.next_token {
object.key("nextToken").string(var_91.as_str());
}
if let Some(var_92) = &input.region_set {
let mut array_93 = object.key("regionSet").start_array();
for item_94 in var_92 {
{
array_93.value().string(item_94.as_str());
}
}
array_93.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_log_sources_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListLogSourcesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_95) = &input.input_order {
let mut array_96 = object.key("inputOrder").start_array();
for item_97 in var_95 {
{
array_96.value().string(item_97.as_str());
}
}
array_96.finish();
}
if let Some(var_98) = &input.list_all_dimensions {
#[allow(unused_mut)]
let mut object_99 = object.key("listAllDimensions").start_object();
for (key_100, value_101) in var_98 {
{
#[allow(unused_mut)]
let mut object_102 = object_99.key(key_100.as_str()).start_object();
for (key_103, value_104) in value_101 {
{
let mut array_105 = object_102.key(key_103.as_str()).start_array();
for item_106 in value_104 {
{
array_105.value().string(item_106.as_str());
}
}
array_105.finish();
}
}
object_102.finish();
}
}
object_99.finish();
}
if let Some(var_107) = &input.list_single_dimension {
let mut array_108 = object.key("listSingleDimension").start_array();
for item_109 in var_107 {
{
array_108.value().string(item_109.as_str());
}
}
array_108.finish();
}
if let Some(var_110) = &input.list_two_dimensions {
#[allow(unused_mut)]
let mut object_111 = object.key("listTwoDimensions").start_object();
for (key_112, value_113) in var_110 {
{
let mut array_114 = object_111.key(key_112.as_str()).start_array();
for item_115 in value_113 {
{
array_114.value().string(item_115.as_str());
}
}
array_114.finish();
}
}
object_111.finish();
}
if let Some(var_116) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_116).into()),
);
}
if let Some(var_117) = &input.next_token {
object.key("nextToken").string(var_117.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_datalake_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDatalakeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_118) = &input.configurations {
#[allow(unused_mut)]
let mut object_119 = object.key("configurations").start_object();
for (key_120, value_121) in var_118 {
{
#[allow(unused_mut)]
let mut object_122 = object_119.key(key_120.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_lake_configuration_request(
&mut object_122,
value_121,
)?;
object_122.finish();
}
}
object_119.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_datalake_exceptions_expiry_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDatalakeExceptionsExpiryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_123) = &input.exception_message_expiry {
object.key("exceptionMessageExpiry").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_123).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_datalake_exceptions_subscription_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDatalakeExceptionsSubscriptionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_124) = &input.notification_endpoint {
object.key("notificationEndpoint").string(var_124.as_str());
}
if let Some(var_125) = &input.subscription_protocol {
object.key("subscriptionProtocol").string(var_125.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_subscriber_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSubscriberInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_126) = &input.external_id {
object.key("externalId").string(var_126.as_str());
}
if let Some(var_127) = &input.source_types {
let mut array_128 = object.key("sourceTypes").start_array();
for item_129 in var_127 {
{
#[allow(unused_mut)]
let mut object_130 = array_128.value().start_object();
crate::json_ser::serialize_union_crate_model_source_type(
&mut object_130,
item_129,
)?;
object_130.finish();
}
}
array_128.finish();
}
if let Some(var_131) = &input.subscriber_description {
object.key("subscriberDescription").string(var_131.as_str());
}
if let Some(var_132) = &input.subscriber_name {
object.key("subscriberName").string(var_132.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_subscription_notification_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSubscriptionNotificationConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_133) = &input.create_sqs {
object.key("createSqs").boolean(*var_133);
}
if let Some(var_134) = &input.https_api_key_name {
object.key("httpsApiKeyName").string(var_134.as_str());
}
if let Some(var_135) = &input.https_api_key_value {
object.key("httpsApiKeyValue").string(var_135.as_str());
}
if let Some(var_136) = &input.https_method {
object.key("httpsMethod").string(var_136.as_str());
}
if let Some(var_137) = &input.role_arn {
object.key("roleArn").string(var_137.as_str());
}
if let Some(var_138) = &input.subscription_endpoint {
object.key("subscriptionEndpoint").string(var_138.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_lake_configuration_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LakeConfigurationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_139) = &input.encryption_key {
object.key("encryptionKey").string(var_139.as_str());
}
if let Some(var_140) = &input.retention_settings {
let mut array_141 = object.key("retentionSettings").start_array();
for item_142 in var_140 {
{
#[allow(unused_mut)]
let mut object_143 = array_141.value().start_object();
crate::json_ser::serialize_structure_crate_model_retention_setting(
&mut object_143,
item_142,
)?;
object_143.finish();
}
}
array_141.finish();
}
if let Some(var_144) = &input.tags_map {
#[allow(unused_mut)]
let mut object_145 = object.key("tagsMap").start_object();
for (key_146, value_147) in var_144 {
{
object_145.key(key_146.as_str()).string(value_147.as_str());
}
}
object_145.finish();
}
if let Some(var_148) = &input.replication_destination_regions {
let mut array_149 = object.key("replicationDestinationRegions").start_array();
for item_150 in var_148 {
{
array_149.value().string(item_150.as_str());
}
}
array_149.finish();
}
if let Some(var_151) = &input.replication_role_arn {
object.key("replicationRoleArn").string(var_151.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_enable_new_region_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoEnableNewRegionConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_152) = &input.region {
object.key("region").string(var_152.as_str());
}
if let Some(var_153) = &input.sources {
let mut array_154 = object.key("sources").start_array();
for item_155 in var_153 {
{
array_154.value().string(item_155.as_str());
}
}
array_154.finish();
}
Ok(())
}
pub fn serialize_union_crate_model_source_type(
object_51: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SourceType,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::SourceType::AwsSourceType(inner) => {
object_51.key("awsSourceType").string(inner.as_str());
}
crate::model::SourceType::CustomSourceType(inner) => {
object_51.key("customSourceType").string(inner.as_str());
}
crate::model::SourceType::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"SourceType",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_retention_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RetentionSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_156) = &input.storage_class {
object.key("storageClass").string(var_156.as_str());
}
if let Some(var_157) = &input.retention_period {
object.key("retentionPeriod").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_157).into()),
);
}
Ok(())
}