json_ser.rs

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
pub fn serialize_structure_crate_input_add_lf_tags_to_resource_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::AddLfTagsToResourceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_1) = &input.catalog_id {
        object.key("CatalogId").string(var_1);
    }
    if let Some(var_2) = &input.lf_tags {
        let mut array_3 = object.key("LFTags").start_array();
        for item_4 in var_2 {
            {
                let mut object_5 = array_3.value().start_object();
                crate::json_ser::serialize_structure_crate_model_lf_tag_pair(
                    &mut object_5,
                    item_4,
                )?;
                object_5.finish();
            }
        }
        array_3.finish();
    }
    if let Some(var_6) = &input.resource {
        let mut object_7 = object.key("Resource").start_object();
        crate::json_ser::serialize_structure_crate_model_resource(&mut object_7, var_6)?;
        object_7.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_batch_grant_permissions_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::BatchGrantPermissionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_8) = &input.catalog_id {
        object.key("CatalogId").string(var_8);
    }
    if let Some(var_9) = &input.entries {
        let mut array_10 = object.key("Entries").start_array();
        for item_11 in var_9 {
            {
                let mut object_12 = array_10.value().start_object();
                crate::json_ser::serialize_structure_crate_model_batch_permissions_request_entry(
                    &mut object_12,
                    item_11,
                )?;
                object_12.finish();
            }
        }
        array_10.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_batch_revoke_permissions_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::BatchRevokePermissionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_13) = &input.catalog_id {
        object.key("CatalogId").string(var_13);
    }
    if let Some(var_14) = &input.entries {
        let mut array_15 = object.key("Entries").start_array();
        for item_16 in var_14 {
            {
                let mut object_17 = array_15.value().start_object();
                crate::json_ser::serialize_structure_crate_model_batch_permissions_request_entry(
                    &mut object_17,
                    item_16,
                )?;
                object_17.finish();
            }
        }
        array_15.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_cancel_transaction_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CancelTransactionInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_18) = &input.transaction_id {
        object.key("TransactionId").string(var_18);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_commit_transaction_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CommitTransactionInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_19) = &input.transaction_id {
        object.key("TransactionId").string(var_19);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_data_cells_filter_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateDataCellsFilterInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_20) = &input.table_data {
        let mut object_21 = object.key("TableData").start_object();
        crate::json_ser::serialize_structure_crate_model_data_cells_filter(&mut object_21, var_20)?;
        object_21.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_lf_tag_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateLfTagInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_22) = &input.catalog_id {
        object.key("CatalogId").string(var_22);
    }
    if let Some(var_23) = &input.tag_key {
        object.key("TagKey").string(var_23);
    }
    if let Some(var_24) = &input.tag_values {
        let mut array_25 = object.key("TagValues").start_array();
        for item_26 in var_24 {
            {
                array_25.value().string(item_26);
            }
        }
        array_25.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_data_cells_filter_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteDataCellsFilterInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_27) = &input.database_name {
        object.key("DatabaseName").string(var_27);
    }
    if let Some(var_28) = &input.name {
        object.key("Name").string(var_28);
    }
    if let Some(var_29) = &input.table_catalog_id {
        object.key("TableCatalogId").string(var_29);
    }
    if let Some(var_30) = &input.table_name {
        object.key("TableName").string(var_30);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_lf_tag_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteLfTagInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_31) = &input.catalog_id {
        object.key("CatalogId").string(var_31);
    }
    if let Some(var_32) = &input.tag_key {
        object.key("TagKey").string(var_32);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_objects_on_cancel_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteObjectsOnCancelInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_33) = &input.catalog_id {
        object.key("CatalogId").string(var_33);
    }
    if let Some(var_34) = &input.database_name {
        object.key("DatabaseName").string(var_34);
    }
    if let Some(var_35) = &input.objects {
        let mut array_36 = object.key("Objects").start_array();
        for item_37 in var_35 {
            {
                let mut object_38 = array_36.value().start_object();
                crate::json_ser::serialize_structure_crate_model_virtual_object(
                    &mut object_38,
                    item_37,
                )?;
                object_38.finish();
            }
        }
        array_36.finish();
    }
    if let Some(var_39) = &input.table_name {
        object.key("TableName").string(var_39);
    }
    if let Some(var_40) = &input.transaction_id {
        object.key("TransactionId").string(var_40);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_deregister_resource_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeregisterResourceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_41) = &input.resource_arn {
        object.key("ResourceArn").string(var_41);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_resource_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeResourceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_42) = &input.resource_arn {
        object.key("ResourceArn").string(var_42);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_transaction_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeTransactionInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_43) = &input.transaction_id {
        object.key("TransactionId").string(var_43);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_extend_transaction_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ExtendTransactionInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_44) = &input.transaction_id {
        object.key("TransactionId").string(var_44);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_data_lake_settings_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetDataLakeSettingsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_45) = &input.catalog_id {
        object.key("CatalogId").string(var_45);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_effective_permissions_for_path_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetEffectivePermissionsForPathInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_46) = &input.catalog_id {
        object.key("CatalogId").string(var_46);
    }
    if let Some(var_47) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_47).into()),
        );
    }
    if let Some(var_48) = &input.next_token {
        object.key("NextToken").string(var_48);
    }
    if let Some(var_49) = &input.resource_arn {
        object.key("ResourceArn").string(var_49);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_lf_tag_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetLfTagInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_50) = &input.catalog_id {
        object.key("CatalogId").string(var_50);
    }
    if let Some(var_51) = &input.tag_key {
        object.key("TagKey").string(var_51);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_query_state_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetQueryStateInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_52) = &input.query_id {
        object.key("QueryId").string(var_52);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_query_statistics_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetQueryStatisticsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_53) = &input.query_id {
        object.key("QueryId").string(var_53);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_resource_lf_tags_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetResourceLfTagsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_54) = &input.catalog_id {
        object.key("CatalogId").string(var_54);
    }
    if let Some(var_55) = &input.resource {
        let mut object_56 = object.key("Resource").start_object();
        crate::json_ser::serialize_structure_crate_model_resource(&mut object_56, var_55)?;
        object_56.finish();
    }
    if let Some(var_57) = &input.show_assigned_lf_tags {
        object.key("ShowAssignedLFTags").boolean(*var_57);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_table_objects_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetTableObjectsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_58) = &input.catalog_id {
        object.key("CatalogId").string(var_58);
    }
    if let Some(var_59) = &input.database_name {
        object.key("DatabaseName").string(var_59);
    }
    if let Some(var_60) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_60).into()),
        );
    }
    if let Some(var_61) = &input.next_token {
        object.key("NextToken").string(var_61);
    }
    if let Some(var_62) = &input.partition_predicate {
        object.key("PartitionPredicate").string(var_62);
    }
    if let Some(var_63) = &input.query_as_of_time {
        object
            .key("QueryAsOfTime")
            .date_time(var_63, aws_smithy_types::date_time::Format::EpochSeconds)?;
    }
    if let Some(var_64) = &input.table_name {
        object.key("TableName").string(var_64);
    }
    if let Some(var_65) = &input.transaction_id {
        object.key("TransactionId").string(var_65);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_temporary_glue_partition_credentials_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetTemporaryGluePartitionCredentialsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_66) = &input.audit_context {
        let mut object_67 = object.key("AuditContext").start_object();
        crate::json_ser::serialize_structure_crate_model_audit_context(&mut object_67, var_66)?;
        object_67.finish();
    }
    if let Some(var_68) = &input.duration_seconds {
        object.key("DurationSeconds").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_68).into()),
        );
    }
    if let Some(var_69) = &input.partition {
        let mut object_70 = object.key("Partition").start_object();
        crate::json_ser::serialize_structure_crate_model_partition_value_list(
            &mut object_70,
            var_69,
        )?;
        object_70.finish();
    }
    if let Some(var_71) = &input.permissions {
        let mut array_72 = object.key("Permissions").start_array();
        for item_73 in var_71 {
            {
                array_72.value().string(item_73.as_str());
            }
        }
        array_72.finish();
    }
    if let Some(var_74) = &input.supported_permission_types {
        let mut array_75 = object.key("SupportedPermissionTypes").start_array();
        for item_76 in var_74 {
            {
                array_75.value().string(item_76.as_str());
            }
        }
        array_75.finish();
    }
    if let Some(var_77) = &input.table_arn {
        object.key("TableArn").string(var_77);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_temporary_glue_table_credentials_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetTemporaryGlueTableCredentialsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_78) = &input.audit_context {
        let mut object_79 = object.key("AuditContext").start_object();
        crate::json_ser::serialize_structure_crate_model_audit_context(&mut object_79, var_78)?;
        object_79.finish();
    }
    if let Some(var_80) = &input.duration_seconds {
        object.key("DurationSeconds").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_80).into()),
        );
    }
    if let Some(var_81) = &input.permissions {
        let mut array_82 = object.key("Permissions").start_array();
        for item_83 in var_81 {
            {
                array_82.value().string(item_83.as_str());
            }
        }
        array_82.finish();
    }
    if let Some(var_84) = &input.supported_permission_types {
        let mut array_85 = object.key("SupportedPermissionTypes").start_array();
        for item_86 in var_84 {
            {
                array_85.value().string(item_86.as_str());
            }
        }
        array_85.finish();
    }
    if let Some(var_87) = &input.table_arn {
        object.key("TableArn").string(var_87);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_work_unit_results_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetWorkUnitResultsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_88) = &input.query_id {
        object.key("QueryId").string(var_88);
    }
    {
        object.key("WorkUnitId").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.work_unit_id).into()),
        );
    }
    if let Some(var_89) = &input.work_unit_token {
        object.key("WorkUnitToken").string(var_89);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_work_units_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetWorkUnitsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_90) = &input.next_token {
        object.key("NextToken").string(var_90);
    }
    if let Some(var_91) = &input.page_size {
        object.key("PageSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_91).into()),
        );
    }
    if let Some(var_92) = &input.query_id {
        object.key("QueryId").string(var_92);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_grant_permissions_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GrantPermissionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_93) = &input.catalog_id {
        object.key("CatalogId").string(var_93);
    }
    if let Some(var_94) = &input.permissions {
        let mut array_95 = object.key("Permissions").start_array();
        for item_96 in var_94 {
            {
                array_95.value().string(item_96.as_str());
            }
        }
        array_95.finish();
    }
    if let Some(var_97) = &input.permissions_with_grant_option {
        let mut array_98 = object.key("PermissionsWithGrantOption").start_array();
        for item_99 in var_97 {
            {
                array_98.value().string(item_99.as_str());
            }
        }
        array_98.finish();
    }
    if let Some(var_100) = &input.principal {
        let mut object_101 = object.key("Principal").start_object();
        crate::json_ser::serialize_structure_crate_model_data_lake_principal(
            &mut object_101,
            var_100,
        )?;
        object_101.finish();
    }
    if let Some(var_102) = &input.resource {
        let mut object_103 = object.key("Resource").start_object();
        crate::json_ser::serialize_structure_crate_model_resource(&mut object_103, var_102)?;
        object_103.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_data_cells_filter_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListDataCellsFilterInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_104) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_104).into()),
        );
    }
    if let Some(var_105) = &input.next_token {
        object.key("NextToken").string(var_105);
    }
    if let Some(var_106) = &input.table {
        let mut object_107 = object.key("Table").start_object();
        crate::json_ser::serialize_structure_crate_model_table_resource(&mut object_107, var_106)?;
        object_107.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_lf_tags_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListLfTagsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_108) = &input.catalog_id {
        object.key("CatalogId").string(var_108);
    }
    if let Some(var_109) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_109).into()),
        );
    }
    if let Some(var_110) = &input.next_token {
        object.key("NextToken").string(var_110);
    }
    if let Some(var_111) = &input.resource_share_type {
        object.key("ResourceShareType").string(var_111.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_permissions_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListPermissionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_112) = &input.catalog_id {
        object.key("CatalogId").string(var_112);
    }
    if let Some(var_113) = &input.include_related {
        object.key("IncludeRelated").string(var_113);
    }
    if let Some(var_114) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_114).into()),
        );
    }
    if let Some(var_115) = &input.next_token {
        object.key("NextToken").string(var_115);
    }
    if let Some(var_116) = &input.principal {
        let mut object_117 = object.key("Principal").start_object();
        crate::json_ser::serialize_structure_crate_model_data_lake_principal(
            &mut object_117,
            var_116,
        )?;
        object_117.finish();
    }
    if let Some(var_118) = &input.resource {
        let mut object_119 = object.key("Resource").start_object();
        crate::json_ser::serialize_structure_crate_model_resource(&mut object_119, var_118)?;
        object_119.finish();
    }
    if let Some(var_120) = &input.resource_type {
        object.key("ResourceType").string(var_120.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_resources_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListResourcesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_121) = &input.filter_condition_list {
        let mut array_122 = object.key("FilterConditionList").start_array();
        for item_123 in var_121 {
            {
                let mut object_124 = array_122.value().start_object();
                crate::json_ser::serialize_structure_crate_model_filter_condition(
                    &mut object_124,
                    item_123,
                )?;
                object_124.finish();
            }
        }
        array_122.finish();
    }
    if let Some(var_125) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_125).into()),
        );
    }
    if let Some(var_126) = &input.next_token {
        object.key("NextToken").string(var_126);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_table_storage_optimizers_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListTableStorageOptimizersInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_127) = &input.catalog_id {
        object.key("CatalogId").string(var_127);
    }
    if let Some(var_128) = &input.database_name {
        object.key("DatabaseName").string(var_128);
    }
    if let Some(var_129) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_129).into()),
        );
    }
    if let Some(var_130) = &input.next_token {
        object.key("NextToken").string(var_130);
    }
    if let Some(var_131) = &input.storage_optimizer_type {
        object.key("StorageOptimizerType").string(var_131.as_str());
    }
    if let Some(var_132) = &input.table_name {
        object.key("TableName").string(var_132);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_transactions_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListTransactionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_133) = &input.catalog_id {
        object.key("CatalogId").string(var_133);
    }
    if let Some(var_134) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_134).into()),
        );
    }
    if let Some(var_135) = &input.next_token {
        object.key("NextToken").string(var_135);
    }
    if let Some(var_136) = &input.status_filter {
        object.key("StatusFilter").string(var_136.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_data_lake_settings_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutDataLakeSettingsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_137) = &input.catalog_id {
        object.key("CatalogId").string(var_137);
    }
    if let Some(var_138) = &input.data_lake_settings {
        let mut object_139 = object.key("DataLakeSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_data_lake_settings(
            &mut object_139,
            var_138,
        )?;
        object_139.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_register_resource_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::RegisterResourceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_140) = &input.resource_arn {
        object.key("ResourceArn").string(var_140);
    }
    if let Some(var_141) = &input.role_arn {
        object.key("RoleArn").string(var_141);
    }
    if let Some(var_142) = &input.use_service_linked_role {
        object.key("UseServiceLinkedRole").boolean(*var_142);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_remove_lf_tags_from_resource_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::RemoveLfTagsFromResourceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_143) = &input.catalog_id {
        object.key("CatalogId").string(var_143);
    }
    if let Some(var_144) = &input.lf_tags {
        let mut array_145 = object.key("LFTags").start_array();
        for item_146 in var_144 {
            {
                let mut object_147 = array_145.value().start_object();
                crate::json_ser::serialize_structure_crate_model_lf_tag_pair(
                    &mut object_147,
                    item_146,
                )?;
                object_147.finish();
            }
        }
        array_145.finish();
    }
    if let Some(var_148) = &input.resource {
        let mut object_149 = object.key("Resource").start_object();
        crate::json_ser::serialize_structure_crate_model_resource(&mut object_149, var_148)?;
        object_149.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_revoke_permissions_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::RevokePermissionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_150) = &input.catalog_id {
        object.key("CatalogId").string(var_150);
    }
    if let Some(var_151) = &input.permissions {
        let mut array_152 = object.key("Permissions").start_array();
        for item_153 in var_151 {
            {
                array_152.value().string(item_153.as_str());
            }
        }
        array_152.finish();
    }
    if let Some(var_154) = &input.permissions_with_grant_option {
        let mut array_155 = object.key("PermissionsWithGrantOption").start_array();
        for item_156 in var_154 {
            {
                array_155.value().string(item_156.as_str());
            }
        }
        array_155.finish();
    }
    if let Some(var_157) = &input.principal {
        let mut object_158 = object.key("Principal").start_object();
        crate::json_ser::serialize_structure_crate_model_data_lake_principal(
            &mut object_158,
            var_157,
        )?;
        object_158.finish();
    }
    if let Some(var_159) = &input.resource {
        let mut object_160 = object.key("Resource").start_object();
        crate::json_ser::serialize_structure_crate_model_resource(&mut object_160, var_159)?;
        object_160.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_search_databases_by_lf_tags_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::SearchDatabasesByLfTagsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_161) = &input.catalog_id {
        object.key("CatalogId").string(var_161);
    }
    if let Some(var_162) = &input.expression {
        let mut array_163 = object.key("Expression").start_array();
        for item_164 in var_162 {
            {
                let mut object_165 = array_163.value().start_object();
                crate::json_ser::serialize_structure_crate_model_lf_tag(&mut object_165, item_164)?;
                object_165.finish();
            }
        }
        array_163.finish();
    }
    if let Some(var_166) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_166).into()),
        );
    }
    if let Some(var_167) = &input.next_token {
        object.key("NextToken").string(var_167);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_search_tables_by_lf_tags_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::SearchTablesByLfTagsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_168) = &input.catalog_id {
        object.key("CatalogId").string(var_168);
    }
    if let Some(var_169) = &input.expression {
        let mut array_170 = object.key("Expression").start_array();
        for item_171 in var_169 {
            {
                let mut object_172 = array_170.value().start_object();
                crate::json_ser::serialize_structure_crate_model_lf_tag(&mut object_172, item_171)?;
                object_172.finish();
            }
        }
        array_170.finish();
    }
    if let Some(var_173) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_173).into()),
        );
    }
    if let Some(var_174) = &input.next_token {
        object.key("NextToken").string(var_174);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_start_query_planning_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::StartQueryPlanningInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_175) = &input.query_planning_context {
        let mut object_176 = object.key("QueryPlanningContext").start_object();
        crate::json_ser::serialize_structure_crate_model_query_planning_context(
            &mut object_176,
            var_175,
        )?;
        object_176.finish();
    }
    if let Some(var_177) = &input.query_string {
        object.key("QueryString").string(var_177);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_start_transaction_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::StartTransactionInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_178) = &input.transaction_type {
        object.key("TransactionType").string(var_178.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_lf_tag_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateLfTagInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_179) = &input.catalog_id {
        object.key("CatalogId").string(var_179);
    }
    if let Some(var_180) = &input.tag_key {
        object.key("TagKey").string(var_180);
    }
    if let Some(var_181) = &input.tag_values_to_add {
        let mut array_182 = object.key("TagValuesToAdd").start_array();
        for item_183 in var_181 {
            {
                array_182.value().string(item_183);
            }
        }
        array_182.finish();
    }
    if let Some(var_184) = &input.tag_values_to_delete {
        let mut array_185 = object.key("TagValuesToDelete").start_array();
        for item_186 in var_184 {
            {
                array_185.value().string(item_186);
            }
        }
        array_185.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_resource_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateResourceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_187) = &input.resource_arn {
        object.key("ResourceArn").string(var_187);
    }
    if let Some(var_188) = &input.role_arn {
        object.key("RoleArn").string(var_188);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_table_objects_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateTableObjectsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_189) = &input.catalog_id {
        object.key("CatalogId").string(var_189);
    }
    if let Some(var_190) = &input.database_name {
        object.key("DatabaseName").string(var_190);
    }
    if let Some(var_191) = &input.table_name {
        object.key("TableName").string(var_191);
    }
    if let Some(var_192) = &input.transaction_id {
        object.key("TransactionId").string(var_192);
    }
    if let Some(var_193) = &input.write_operations {
        let mut array_194 = object.key("WriteOperations").start_array();
        for item_195 in var_193 {
            {
                let mut object_196 = array_194.value().start_object();
                crate::json_ser::serialize_structure_crate_model_write_operation(
                    &mut object_196,
                    item_195,
                )?;
                object_196.finish();
            }
        }
        array_194.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_table_storage_optimizer_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateTableStorageOptimizerInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_197) = &input.catalog_id {
        object.key("CatalogId").string(var_197);
    }
    if let Some(var_198) = &input.database_name {
        object.key("DatabaseName").string(var_198);
    }
    if let Some(var_199) = &input.storage_optimizer_config {
        let mut object_200 = object.key("StorageOptimizerConfig").start_object();
        for (key_201, value_202) in var_199 {
            {
                let mut object_203 = object_200.key(key_201.as_str()).start_object();
                for (key_204, value_205) in value_202 {
                    {
                        object_203.key(key_204).string(value_205);
                    }
                }
                object_203.finish();
            }
        }
        object_200.finish();
    }
    if let Some(var_206) = &input.table_name {
        object.key("TableName").string(var_206);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_lf_tag_pair(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::LfTagPair,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_207) = &input.catalog_id {
        object.key("CatalogId").string(var_207);
    }
    if let Some(var_208) = &input.tag_key {
        object.key("TagKey").string(var_208);
    }
    if let Some(var_209) = &input.tag_values {
        let mut array_210 = object.key("TagValues").start_array();
        for item_211 in var_209 {
            {
                array_210.value().string(item_211);
            }
        }
        array_210.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_resource(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Resource,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_212) = &input.catalog {
        let mut object_213 = object.key("Catalog").start_object();
        crate::json_ser::serialize_structure_crate_model_catalog_resource(
            &mut object_213,
            var_212,
        )?;
        object_213.finish();
    }
    if let Some(var_214) = &input.database {
        let mut object_215 = object.key("Database").start_object();
        crate::json_ser::serialize_structure_crate_model_database_resource(
            &mut object_215,
            var_214,
        )?;
        object_215.finish();
    }
    if let Some(var_216) = &input.table {
        let mut object_217 = object.key("Table").start_object();
        crate::json_ser::serialize_structure_crate_model_table_resource(&mut object_217, var_216)?;
        object_217.finish();
    }
    if let Some(var_218) = &input.table_with_columns {
        let mut object_219 = object.key("TableWithColumns").start_object();
        crate::json_ser::serialize_structure_crate_model_table_with_columns_resource(
            &mut object_219,
            var_218,
        )?;
        object_219.finish();
    }
    if let Some(var_220) = &input.data_location {
        let mut object_221 = object.key("DataLocation").start_object();
        crate::json_ser::serialize_structure_crate_model_data_location_resource(
            &mut object_221,
            var_220,
        )?;
        object_221.finish();
    }
    if let Some(var_222) = &input.data_cells_filter {
        let mut object_223 = object.key("DataCellsFilter").start_object();
        crate::json_ser::serialize_structure_crate_model_data_cells_filter_resource(
            &mut object_223,
            var_222,
        )?;
        object_223.finish();
    }
    if let Some(var_224) = &input.lf_tag {
        let mut object_225 = object.key("LFTag").start_object();
        crate::json_ser::serialize_structure_crate_model_lf_tag_key_resource(
            &mut object_225,
            var_224,
        )?;
        object_225.finish();
    }
    if let Some(var_226) = &input.lf_tag_policy {
        let mut object_227 = object.key("LFTagPolicy").start_object();
        crate::json_ser::serialize_structure_crate_model_lf_tag_policy_resource(
            &mut object_227,
            var_226,
        )?;
        object_227.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_batch_permissions_request_entry(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::BatchPermissionsRequestEntry,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_228) = &input.id {
        object.key("Id").string(var_228);
    }
    if let Some(var_229) = &input.principal {
        let mut object_230 = object.key("Principal").start_object();
        crate::json_ser::serialize_structure_crate_model_data_lake_principal(
            &mut object_230,
            var_229,
        )?;
        object_230.finish();
    }
    if let Some(var_231) = &input.resource {
        let mut object_232 = object.key("Resource").start_object();
        crate::json_ser::serialize_structure_crate_model_resource(&mut object_232, var_231)?;
        object_232.finish();
    }
    if let Some(var_233) = &input.permissions {
        let mut array_234 = object.key("Permissions").start_array();
        for item_235 in var_233 {
            {
                array_234.value().string(item_235.as_str());
            }
        }
        array_234.finish();
    }
    if let Some(var_236) = &input.permissions_with_grant_option {
        let mut array_237 = object.key("PermissionsWithGrantOption").start_array();
        for item_238 in var_236 {
            {
                array_237.value().string(item_238.as_str());
            }
        }
        array_237.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_data_cells_filter(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DataCellsFilter,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_239) = &input.table_catalog_id {
        object.key("TableCatalogId").string(var_239);
    }
    if let Some(var_240) = &input.database_name {
        object.key("DatabaseName").string(var_240);
    }
    if let Some(var_241) = &input.table_name {
        object.key("TableName").string(var_241);
    }
    if let Some(var_242) = &input.name {
        object.key("Name").string(var_242);
    }
    if let Some(var_243) = &input.row_filter {
        let mut object_244 = object.key("RowFilter").start_object();
        crate::json_ser::serialize_structure_crate_model_row_filter(&mut object_244, var_243)?;
        object_244.finish();
    }
    if let Some(var_245) = &input.column_names {
        let mut array_246 = object.key("ColumnNames").start_array();
        for item_247 in var_245 {
            {
                array_246.value().string(item_247);
            }
        }
        array_246.finish();
    }
    if let Some(var_248) = &input.column_wildcard {
        let mut object_249 = object.key("ColumnWildcard").start_object();
        crate::json_ser::serialize_structure_crate_model_column_wildcard(&mut object_249, var_248)?;
        object_249.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_object(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualObject,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_250) = &input.uri {
        object.key("Uri").string(var_250);
    }
    if let Some(var_251) = &input.e_tag {
        object.key("ETag").string(var_251);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_audit_context(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AuditContext,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_252) = &input.additional_audit_context {
        object.key("AdditionalAuditContext").string(var_252);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_partition_value_list(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::PartitionValueList,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_253) = &input.values {
        let mut array_254 = object.key("Values").start_array();
        for item_255 in var_253 {
            {
                array_254.value().string(item_255);
            }
        }
        array_254.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_data_lake_principal(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DataLakePrincipal,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_256) = &input.data_lake_principal_identifier {
        object.key("DataLakePrincipalIdentifier").string(var_256);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_table_resource(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TableResource,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_257) = &input.catalog_id {
        object.key("CatalogId").string(var_257);
    }
    if let Some(var_258) = &input.database_name {
        object.key("DatabaseName").string(var_258);
    }
    if let Some(var_259) = &input.name {
        object.key("Name").string(var_259);
    }
    if let Some(var_260) = &input.table_wildcard {
        let mut object_261 = object.key("TableWildcard").start_object();
        crate::json_ser::serialize_structure_crate_model_table_wildcard(&mut object_261, var_260)?;
        object_261.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_filter_condition(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::FilterCondition,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_262) = &input.field {
        object.key("Field").string(var_262.as_str());
    }
    if let Some(var_263) = &input.comparison_operator {
        object.key("ComparisonOperator").string(var_263.as_str());
    }
    if let Some(var_264) = &input.string_value_list {
        let mut array_265 = object.key("StringValueList").start_array();
        for item_266 in var_264 {
            {
                array_265.value().string(item_266);
            }
        }
        array_265.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_data_lake_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DataLakeSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_267) = &input.data_lake_admins {
        let mut array_268 = object.key("DataLakeAdmins").start_array();
        for item_269 in var_267 {
            {
                let mut object_270 = array_268.value().start_object();
                crate::json_ser::serialize_structure_crate_model_data_lake_principal(
                    &mut object_270,
                    item_269,
                )?;
                object_270.finish();
            }
        }
        array_268.finish();
    }
    if let Some(var_271) = &input.create_database_default_permissions {
        let mut array_272 = object.key("CreateDatabaseDefaultPermissions").start_array();
        for item_273 in var_271 {
            {
                let mut object_274 = array_272.value().start_object();
                crate::json_ser::serialize_structure_crate_model_principal_permissions(
                    &mut object_274,
                    item_273,
                )?;
                object_274.finish();
            }
        }
        array_272.finish();
    }
    if let Some(var_275) = &input.create_table_default_permissions {
        let mut array_276 = object.key("CreateTableDefaultPermissions").start_array();
        for item_277 in var_275 {
            {
                let mut object_278 = array_276.value().start_object();
                crate::json_ser::serialize_structure_crate_model_principal_permissions(
                    &mut object_278,
                    item_277,
                )?;
                object_278.finish();
            }
        }
        array_276.finish();
    }
    if let Some(var_279) = &input.trusted_resource_owners {
        let mut array_280 = object.key("TrustedResourceOwners").start_array();
        for item_281 in var_279 {
            {
                array_280.value().string(item_281);
            }
        }
        array_280.finish();
    }
    if let Some(var_282) = &input.allow_external_data_filtering {
        object.key("AllowExternalDataFiltering").boolean(*var_282);
    }
    if let Some(var_283) = &input.external_data_filtering_allow_list {
        let mut array_284 = object.key("ExternalDataFilteringAllowList").start_array();
        for item_285 in var_283 {
            {
                let mut object_286 = array_284.value().start_object();
                crate::json_ser::serialize_structure_crate_model_data_lake_principal(
                    &mut object_286,
                    item_285,
                )?;
                object_286.finish();
            }
        }
        array_284.finish();
    }
    if let Some(var_287) = &input.authorized_session_tag_value_list {
        let mut array_288 = object.key("AuthorizedSessionTagValueList").start_array();
        for item_289 in var_287 {
            {
                array_288.value().string(item_289);
            }
        }
        array_288.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_lf_tag(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::LfTag,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_290) = &input.tag_key {
        object.key("TagKey").string(var_290);
    }
    if let Some(var_291) = &input.tag_values {
        let mut array_292 = object.key("TagValues").start_array();
        for item_293 in var_291 {
            {
                array_292.value().string(item_293);
            }
        }
        array_292.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_query_planning_context(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::QueryPlanningContext,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_294) = &input.catalog_id {
        object.key("CatalogId").string(var_294);
    }
    if let Some(var_295) = &input.database_name {
        object.key("DatabaseName").string(var_295);
    }
    if let Some(var_296) = &input.query_as_of_time {
        object
            .key("QueryAsOfTime")
            .date_time(var_296, aws_smithy_types::date_time::Format::EpochSeconds)?;
    }
    if let Some(var_297) = &input.query_parameters {
        let mut object_298 = object.key("QueryParameters").start_object();
        for (key_299, value_300) in var_297 {
            {
                object_298.key(key_299).string(value_300);
            }
        }
        object_298.finish();
    }
    if let Some(var_301) = &input.transaction_id {
        object.key("TransactionId").string(var_301);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_write_operation(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::WriteOperation,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_302) = &input.add_object {
        let mut object_303 = object.key("AddObject").start_object();
        crate::json_ser::serialize_structure_crate_model_add_object_input(
            &mut object_303,
            var_302,
        )?;
        object_303.finish();
    }
    if let Some(var_304) = &input.delete_object {
        let mut object_305 = object.key("DeleteObject").start_object();
        crate::json_ser::serialize_structure_crate_model_delete_object_input(
            &mut object_305,
            var_304,
        )?;
        object_305.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_catalog_resource(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::CatalogResource,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    let (_, _) = (object, input);
    Ok(())
}

pub fn serialize_structure_crate_model_database_resource(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DatabaseResource,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_306) = &input.catalog_id {
        object.key("CatalogId").string(var_306);
    }
    if let Some(var_307) = &input.name {
        object.key("Name").string(var_307);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_table_with_columns_resource(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TableWithColumnsResource,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_308) = &input.catalog_id {
        object.key("CatalogId").string(var_308);
    }
    if let Some(var_309) = &input.database_name {
        object.key("DatabaseName").string(var_309);
    }
    if let Some(var_310) = &input.name {
        object.key("Name").string(var_310);
    }
    if let Some(var_311) = &input.column_names {
        let mut array_312 = object.key("ColumnNames").start_array();
        for item_313 in var_311 {
            {
                array_312.value().string(item_313);
            }
        }
        array_312.finish();
    }
    if let Some(var_314) = &input.column_wildcard {
        let mut object_315 = object.key("ColumnWildcard").start_object();
        crate::json_ser::serialize_structure_crate_model_column_wildcard(&mut object_315, var_314)?;
        object_315.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_data_location_resource(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DataLocationResource,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_316) = &input.catalog_id {
        object.key("CatalogId").string(var_316);
    }
    if let Some(var_317) = &input.resource_arn {
        object.key("ResourceArn").string(var_317);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_data_cells_filter_resource(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DataCellsFilterResource,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_318) = &input.table_catalog_id {
        object.key("TableCatalogId").string(var_318);
    }
    if let Some(var_319) = &input.database_name {
        object.key("DatabaseName").string(var_319);
    }
    if let Some(var_320) = &input.table_name {
        object.key("TableName").string(var_320);
    }
    if let Some(var_321) = &input.name {
        object.key("Name").string(var_321);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_lf_tag_key_resource(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::LfTagKeyResource,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_322) = &input.catalog_id {
        object.key("CatalogId").string(var_322);
    }
    if let Some(var_323) = &input.tag_key {
        object.key("TagKey").string(var_323);
    }
    if let Some(var_324) = &input.tag_values {
        let mut array_325 = object.key("TagValues").start_array();
        for item_326 in var_324 {
            {
                array_325.value().string(item_326);
            }
        }
        array_325.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_lf_tag_policy_resource(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::LfTagPolicyResource,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_327) = &input.catalog_id {
        object.key("CatalogId").string(var_327);
    }
    if let Some(var_328) = &input.resource_type {
        object.key("ResourceType").string(var_328.as_str());
    }
    if let Some(var_329) = &input.expression {
        let mut array_330 = object.key("Expression").start_array();
        for item_331 in var_329 {
            {
                let mut object_332 = array_330.value().start_object();
                crate::json_ser::serialize_structure_crate_model_lf_tag(&mut object_332, item_331)?;
                object_332.finish();
            }
        }
        array_330.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_row_filter(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::RowFilter,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_333) = &input.filter_expression {
        object.key("FilterExpression").string(var_333);
    }
    if let Some(var_334) = &input.all_rows_wildcard {
        let mut object_335 = object.key("AllRowsWildcard").start_object();
        crate::json_ser::serialize_structure_crate_model_all_rows_wildcard(
            &mut object_335,
            var_334,
        )?;
        object_335.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_column_wildcard(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ColumnWildcard,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_336) = &input.excluded_column_names {
        let mut array_337 = object.key("ExcludedColumnNames").start_array();
        for item_338 in var_336 {
            {
                array_337.value().string(item_338);
            }
        }
        array_337.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_table_wildcard(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TableWildcard,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    let (_, _) = (object, input);
    Ok(())
}

pub fn serialize_structure_crate_model_principal_permissions(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::PrincipalPermissions,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_339) = &input.principal {
        let mut object_340 = object.key("Principal").start_object();
        crate::json_ser::serialize_structure_crate_model_data_lake_principal(
            &mut object_340,
            var_339,
        )?;
        object_340.finish();
    }
    if let Some(var_341) = &input.permissions {
        let mut array_342 = object.key("Permissions").start_array();
        for item_343 in var_341 {
            {
                array_342.value().string(item_343.as_str());
            }
        }
        array_342.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_add_object_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AddObjectInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_344) = &input.uri {
        object.key("Uri").string(var_344);
    }
    if let Some(var_345) = &input.e_tag {
        object.key("ETag").string(var_345);
    }
    {
        object.key("Size").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.size).into()),
        );
    }
    if let Some(var_346) = &input.partition_values {
        let mut array_347 = object.key("PartitionValues").start_array();
        for item_348 in var_346 {
            {
                array_347.value().string(item_348);
            }
        }
        array_347.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_delete_object_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DeleteObjectInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_349) = &input.uri {
        object.key("Uri").string(var_349);
    }
    if let Some(var_350) = &input.e_tag {
        object.key("ETag").string(var_350);
    }
    if let Some(var_351) = &input.partition_values {
        let mut array_352 = object.key("PartitionValues").start_array();
        for item_353 in var_351 {
            {
                array_352.value().string(item_353);
            }
        }
        array_352.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_all_rows_wildcard(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AllRowsWildcard,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    let (_, _) = (object, input);
    Ok(())
}