pub fn serialize_structure_crate_input_create_connector_profile_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateConnectorProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.connection_mode {
object.key("connectionMode").string(var_1.as_str());
}
if let Some(var_2) = &input.connector_label {
object.key("connectorLabel").string(var_2.as_str());
}
if let Some(var_3) = &input.connector_profile_config {
#[allow(unused_mut)]
let mut object_4 = object.key("connectorProfileConfig").start_object();
crate::json_ser::serialize_structure_crate_model_connector_profile_config(
&mut object_4,
var_3,
)?;
object_4.finish();
}
if let Some(var_5) = &input.connector_profile_name {
object.key("connectorProfileName").string(var_5.as_str());
}
if let Some(var_6) = &input.connector_type {
object.key("connectorType").string(var_6.as_str());
}
if let Some(var_7) = &input.kms_arn {
object.key("kmsArn").string(var_7.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_flow_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFlowInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_8) = &input.description {
object.key("description").string(var_8.as_str());
}
if let Some(var_9) = &input.destination_flow_config_list {
let mut array_10 = object.key("destinationFlowConfigList").start_array();
for item_11 in var_9 {
{
#[allow(unused_mut)]
let mut object_12 = array_10.value().start_object();
crate::json_ser::serialize_structure_crate_model_destination_flow_config(
&mut object_12,
item_11,
)?;
object_12.finish();
}
}
array_10.finish();
}
if let Some(var_13) = &input.flow_name {
object.key("flowName").string(var_13.as_str());
}
if let Some(var_14) = &input.kms_arn {
object.key("kmsArn").string(var_14.as_str());
}
if let Some(var_15) = &input.metadata_catalog_config {
#[allow(unused_mut)]
let mut object_16 = object.key("metadataCatalogConfig").start_object();
crate::json_ser::serialize_structure_crate_model_metadata_catalog_config(
&mut object_16,
var_15,
)?;
object_16.finish();
}
if let Some(var_17) = &input.source_flow_config {
#[allow(unused_mut)]
let mut object_18 = object.key("sourceFlowConfig").start_object();
crate::json_ser::serialize_structure_crate_model_source_flow_config(
&mut object_18,
var_17,
)?;
object_18.finish();
}
if let Some(var_19) = &input.tags {
#[allow(unused_mut)]
let mut object_20 = object.key("tags").start_object();
for (key_21, value_22) in var_19 {
{
object_20.key(key_21.as_str()).string(value_22.as_str());
}
}
object_20.finish();
}
if let Some(var_23) = &input.tasks {
let mut array_24 = object.key("tasks").start_array();
for item_25 in var_23 {
{
#[allow(unused_mut)]
let mut object_26 = array_24.value().start_object();
crate::json_ser::serialize_structure_crate_model_task(&mut object_26, item_25)?;
object_26.finish();
}
}
array_24.finish();
}
if let Some(var_27) = &input.trigger_config {
#[allow(unused_mut)]
let mut object_28 = object.key("triggerConfig").start_object();
crate::json_ser::serialize_structure_crate_model_trigger_config(&mut object_28, var_27)?;
object_28.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_connector_profile_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteConnectorProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_29) = &input.connector_profile_name {
object.key("connectorProfileName").string(var_29.as_str());
}
if input.force_delete {
object.key("forceDelete").boolean(input.force_delete);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_flow_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteFlowInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_30) = &input.flow_name {
object.key("flowName").string(var_30.as_str());
}
if input.force_delete {
object.key("forceDelete").boolean(input.force_delete);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_connector_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeConnectorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_31) = &input.connector_label {
object.key("connectorLabel").string(var_31.as_str());
}
if let Some(var_32) = &input.connector_type {
object.key("connectorType").string(var_32.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_connector_entity_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeConnectorEntityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_33) = &input.api_version {
object.key("apiVersion").string(var_33.as_str());
}
if let Some(var_34) = &input.connector_entity_name {
object.key("connectorEntityName").string(var_34.as_str());
}
if let Some(var_35) = &input.connector_profile_name {
object.key("connectorProfileName").string(var_35.as_str());
}
if let Some(var_36) = &input.connector_type {
object.key("connectorType").string(var_36.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_connector_profiles_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeConnectorProfilesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_37) = &input.connector_label {
object.key("connectorLabel").string(var_37.as_str());
}
if let Some(var_38) = &input.connector_profile_names {
let mut array_39 = object.key("connectorProfileNames").start_array();
for item_40 in var_38 {
{
array_39.value().string(item_40.as_str());
}
}
array_39.finish();
}
if let Some(var_41) = &input.connector_type {
object.key("connectorType").string(var_41.as_str());
}
if let Some(var_42) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_42).into()),
);
}
if let Some(var_43) = &input.next_token {
object.key("nextToken").string(var_43.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_connectors_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeConnectorsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_44) = &input.connector_types {
let mut array_45 = object.key("connectorTypes").start_array();
for item_46 in var_44 {
{
array_45.value().string(item_46.as_str());
}
}
array_45.finish();
}
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.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_flow_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeFlowInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_49) = &input.flow_name {
object.key("flowName").string(var_49.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_flow_execution_records_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeFlowExecutionRecordsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_50) = &input.flow_name {
object.key("flowName").string(var_50.as_str());
}
if let Some(var_51) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_51).into()),
);
}
if let Some(var_52) = &input.next_token {
object.key("nextToken").string(var_52.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_connector_entities_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListConnectorEntitiesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_53) = &input.api_version {
object.key("apiVersion").string(var_53.as_str());
}
if let Some(var_54) = &input.connector_profile_name {
object.key("connectorProfileName").string(var_54.as_str());
}
if let Some(var_55) = &input.connector_type {
object.key("connectorType").string(var_55.as_str());
}
if let Some(var_56) = &input.entities_path {
object.key("entitiesPath").string(var_56.as_str());
}
if let Some(var_57) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_57).into()),
);
}
if let Some(var_58) = &input.next_token {
object.key("nextToken").string(var_58.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_connectors_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListConnectorsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_59) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_59).into()),
);
}
if let Some(var_60) = &input.next_token {
object.key("nextToken").string(var_60.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_flows_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListFlowsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_61) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_61).into()),
);
}
if let Some(var_62) = &input.next_token {
object.key("nextToken").string(var_62.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_register_connector_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterConnectorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_63) = &input.connector_label {
object.key("connectorLabel").string(var_63.as_str());
}
if let Some(var_64) = &input.connector_provisioning_config {
#[allow(unused_mut)]
let mut object_65 = object.key("connectorProvisioningConfig").start_object();
crate::json_ser::serialize_structure_crate_model_connector_provisioning_config(
&mut object_65,
var_64,
)?;
object_65.finish();
}
if let Some(var_66) = &input.connector_provisioning_type {
object
.key("connectorProvisioningType")
.string(var_66.as_str());
}
if let Some(var_67) = &input.description {
object.key("description").string(var_67.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_flow_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartFlowInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_68) = &input.flow_name {
object.key("flowName").string(var_68.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_flow_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopFlowInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_69) = &input.flow_name {
object.key("flowName").string(var_69.as_str());
}
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_70) = &input.tags {
#[allow(unused_mut)]
let mut object_71 = object.key("tags").start_object();
for (key_72, value_73) in var_70 {
{
object_71.key(key_72.as_str()).string(value_73.as_str());
}
}
object_71.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_unregister_connector_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UnregisterConnectorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_74) = &input.connector_label {
object.key("connectorLabel").string(var_74.as_str());
}
if input.force_delete {
object.key("forceDelete").boolean(input.force_delete);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_connector_profile_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateConnectorProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_75) = &input.connection_mode {
object.key("connectionMode").string(var_75.as_str());
}
if let Some(var_76) = &input.connector_profile_config {
#[allow(unused_mut)]
let mut object_77 = object.key("connectorProfileConfig").start_object();
crate::json_ser::serialize_structure_crate_model_connector_profile_config(
&mut object_77,
var_76,
)?;
object_77.finish();
}
if let Some(var_78) = &input.connector_profile_name {
object.key("connectorProfileName").string(var_78.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_connector_registration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateConnectorRegistrationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_79) = &input.connector_label {
object.key("connectorLabel").string(var_79.as_str());
}
if let Some(var_80) = &input.connector_provisioning_config {
#[allow(unused_mut)]
let mut object_81 = object.key("connectorProvisioningConfig").start_object();
crate::json_ser::serialize_structure_crate_model_connector_provisioning_config(
&mut object_81,
var_80,
)?;
object_81.finish();
}
if let Some(var_82) = &input.description {
object.key("description").string(var_82.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_flow_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFlowInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_83) = &input.description {
object.key("description").string(var_83.as_str());
}
if let Some(var_84) = &input.destination_flow_config_list {
let mut array_85 = object.key("destinationFlowConfigList").start_array();
for item_86 in var_84 {
{
#[allow(unused_mut)]
let mut object_87 = array_85.value().start_object();
crate::json_ser::serialize_structure_crate_model_destination_flow_config(
&mut object_87,
item_86,
)?;
object_87.finish();
}
}
array_85.finish();
}
if let Some(var_88) = &input.flow_name {
object.key("flowName").string(var_88.as_str());
}
if let Some(var_89) = &input.metadata_catalog_config {
#[allow(unused_mut)]
let mut object_90 = object.key("metadataCatalogConfig").start_object();
crate::json_ser::serialize_structure_crate_model_metadata_catalog_config(
&mut object_90,
var_89,
)?;
object_90.finish();
}
if let Some(var_91) = &input.source_flow_config {
#[allow(unused_mut)]
let mut object_92 = object.key("sourceFlowConfig").start_object();
crate::json_ser::serialize_structure_crate_model_source_flow_config(
&mut object_92,
var_91,
)?;
object_92.finish();
}
if let Some(var_93) = &input.tasks {
let mut array_94 = object.key("tasks").start_array();
for item_95 in var_93 {
{
#[allow(unused_mut)]
let mut object_96 = array_94.value().start_object();
crate::json_ser::serialize_structure_crate_model_task(&mut object_96, item_95)?;
object_96.finish();
}
}
array_94.finish();
}
if let Some(var_97) = &input.trigger_config {
#[allow(unused_mut)]
let mut object_98 = object.key("triggerConfig").start_object();
crate::json_ser::serialize_structure_crate_model_trigger_config(&mut object_98, var_97)?;
object_98.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_connector_profile_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConnectorProfileConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_99) = &input.connector_profile_properties {
#[allow(unused_mut)]
let mut object_100 = object.key("connectorProfileProperties").start_object();
crate::json_ser::serialize_structure_crate_model_connector_profile_properties(
&mut object_100,
var_99,
)?;
object_100.finish();
}
if let Some(var_101) = &input.connector_profile_credentials {
#[allow(unused_mut)]
let mut object_102 = object.key("connectorProfileCredentials").start_object();
crate::json_ser::serialize_structure_crate_model_connector_profile_credentials(
&mut object_102,
var_101,
)?;
object_102.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_destination_flow_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DestinationFlowConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_103) = &input.connector_type {
object.key("connectorType").string(var_103.as_str());
}
if let Some(var_104) = &input.api_version {
object.key("apiVersion").string(var_104.as_str());
}
if let Some(var_105) = &input.connector_profile_name {
object.key("connectorProfileName").string(var_105.as_str());
}
if let Some(var_106) = &input.destination_connector_properties {
#[allow(unused_mut)]
let mut object_107 = object.key("destinationConnectorProperties").start_object();
crate::json_ser::serialize_structure_crate_model_destination_connector_properties(
&mut object_107,
var_106,
)?;
object_107.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_metadata_catalog_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MetadataCatalogConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_108) = &input.glue_data_catalog {
#[allow(unused_mut)]
let mut object_109 = object.key("glueDataCatalog").start_object();
crate::json_ser::serialize_structure_crate_model_glue_data_catalog_config(
&mut object_109,
var_108,
)?;
object_109.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_source_flow_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SourceFlowConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_110) = &input.connector_type {
object.key("connectorType").string(var_110.as_str());
}
if let Some(var_111) = &input.api_version {
object.key("apiVersion").string(var_111.as_str());
}
if let Some(var_112) = &input.connector_profile_name {
object.key("connectorProfileName").string(var_112.as_str());
}
if let Some(var_113) = &input.source_connector_properties {
#[allow(unused_mut)]
let mut object_114 = object.key("sourceConnectorProperties").start_object();
crate::json_ser::serialize_structure_crate_model_source_connector_properties(
&mut object_114,
var_113,
)?;
object_114.finish();
}
if let Some(var_115) = &input.incremental_pull_config {
#[allow(unused_mut)]
let mut object_116 = object.key("incrementalPullConfig").start_object();
crate::json_ser::serialize_structure_crate_model_incremental_pull_config(
&mut object_116,
var_115,
)?;
object_116.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_task(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Task,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_117) = &input.source_fields {
let mut array_118 = object.key("sourceFields").start_array();
for item_119 in var_117 {
{
array_118.value().string(item_119.as_str());
}
}
array_118.finish();
}
if let Some(var_120) = &input.connector_operator {
#[allow(unused_mut)]
let mut object_121 = object.key("connectorOperator").start_object();
crate::json_ser::serialize_structure_crate_model_connector_operator(
&mut object_121,
var_120,
)?;
object_121.finish();
}
if let Some(var_122) = &input.destination_field {
object.key("destinationField").string(var_122.as_str());
}
if let Some(var_123) = &input.task_type {
object.key("taskType").string(var_123.as_str());
}
if let Some(var_124) = &input.task_properties {
#[allow(unused_mut)]
let mut object_125 = object.key("taskProperties").start_object();
for (key_126, value_127) in var_124 {
{
object_125.key(key_126.as_str()).string(value_127.as_str());
}
}
object_125.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_trigger_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TriggerConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_128) = &input.trigger_type {
object.key("triggerType").string(var_128.as_str());
}
if let Some(var_129) = &input.trigger_properties {
#[allow(unused_mut)]
let mut object_130 = object.key("triggerProperties").start_object();
crate::json_ser::serialize_structure_crate_model_trigger_properties(
&mut object_130,
var_129,
)?;
object_130.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_connector_provisioning_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConnectorProvisioningConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_131) = &input.lambda {
#[allow(unused_mut)]
let mut object_132 = object.key("lambda").start_object();
crate::json_ser::serialize_structure_crate_model_lambda_connector_provisioning_config(
&mut object_132,
var_131,
)?;
object_132.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_connector_profile_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConnectorProfileProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_133) = &input.amplitude {
#[allow(unused_mut)]
let mut object_134 = object.key("Amplitude").start_object();
crate::json_ser::serialize_structure_crate_model_amplitude_connector_profile_properties(
&mut object_134,
var_133,
)?;
object_134.finish();
}
if let Some(var_135) = &input.datadog {
#[allow(unused_mut)]
let mut object_136 = object.key("Datadog").start_object();
crate::json_ser::serialize_structure_crate_model_datadog_connector_profile_properties(
&mut object_136,
var_135,
)?;
object_136.finish();
}
if let Some(var_137) = &input.dynatrace {
#[allow(unused_mut)]
let mut object_138 = object.key("Dynatrace").start_object();
crate::json_ser::serialize_structure_crate_model_dynatrace_connector_profile_properties(
&mut object_138,
var_137,
)?;
object_138.finish();
}
if let Some(var_139) = &input.google_analytics {
#[allow(unused_mut)]
let mut object_140 = object.key("GoogleAnalytics").start_object();
crate::json_ser::serialize_structure_crate_model_google_analytics_connector_profile_properties(&mut object_140, var_139)?;
object_140.finish();
}
if let Some(var_141) = &input.honeycode {
#[allow(unused_mut)]
let mut object_142 = object.key("Honeycode").start_object();
crate::json_ser::serialize_structure_crate_model_honeycode_connector_profile_properties(
&mut object_142,
var_141,
)?;
object_142.finish();
}
if let Some(var_143) = &input.infor_nexus {
#[allow(unused_mut)]
let mut object_144 = object.key("InforNexus").start_object();
crate::json_ser::serialize_structure_crate_model_infor_nexus_connector_profile_properties(
&mut object_144,
var_143,
)?;
object_144.finish();
}
if let Some(var_145) = &input.marketo {
#[allow(unused_mut)]
let mut object_146 = object.key("Marketo").start_object();
crate::json_ser::serialize_structure_crate_model_marketo_connector_profile_properties(
&mut object_146,
var_145,
)?;
object_146.finish();
}
if let Some(var_147) = &input.redshift {
#[allow(unused_mut)]
let mut object_148 = object.key("Redshift").start_object();
crate::json_ser::serialize_structure_crate_model_redshift_connector_profile_properties(
&mut object_148,
var_147,
)?;
object_148.finish();
}
if let Some(var_149) = &input.salesforce {
#[allow(unused_mut)]
let mut object_150 = object.key("Salesforce").start_object();
crate::json_ser::serialize_structure_crate_model_salesforce_connector_profile_properties(
&mut object_150,
var_149,
)?;
object_150.finish();
}
if let Some(var_151) = &input.service_now {
#[allow(unused_mut)]
let mut object_152 = object.key("ServiceNow").start_object();
crate::json_ser::serialize_structure_crate_model_service_now_connector_profile_properties(
&mut object_152,
var_151,
)?;
object_152.finish();
}
if let Some(var_153) = &input.singular {
#[allow(unused_mut)]
let mut object_154 = object.key("Singular").start_object();
crate::json_ser::serialize_structure_crate_model_singular_connector_profile_properties(
&mut object_154,
var_153,
)?;
object_154.finish();
}
if let Some(var_155) = &input.slack {
#[allow(unused_mut)]
let mut object_156 = object.key("Slack").start_object();
crate::json_ser::serialize_structure_crate_model_slack_connector_profile_properties(
&mut object_156,
var_155,
)?;
object_156.finish();
}
if let Some(var_157) = &input.snowflake {
#[allow(unused_mut)]
let mut object_158 = object.key("Snowflake").start_object();
crate::json_ser::serialize_structure_crate_model_snowflake_connector_profile_properties(
&mut object_158,
var_157,
)?;
object_158.finish();
}
if let Some(var_159) = &input.trendmicro {
#[allow(unused_mut)]
let mut object_160 = object.key("Trendmicro").start_object();
crate::json_ser::serialize_structure_crate_model_trendmicro_connector_profile_properties(
&mut object_160,
var_159,
)?;
object_160.finish();
}
if let Some(var_161) = &input.veeva {
#[allow(unused_mut)]
let mut object_162 = object.key("Veeva").start_object();
crate::json_ser::serialize_structure_crate_model_veeva_connector_profile_properties(
&mut object_162,
var_161,
)?;
object_162.finish();
}
if let Some(var_163) = &input.zendesk {
#[allow(unused_mut)]
let mut object_164 = object.key("Zendesk").start_object();
crate::json_ser::serialize_structure_crate_model_zendesk_connector_profile_properties(
&mut object_164,
var_163,
)?;
object_164.finish();
}
if let Some(var_165) = &input.sapo_data {
#[allow(unused_mut)]
let mut object_166 = object.key("SAPOData").start_object();
crate::json_ser::serialize_structure_crate_model_sapo_data_connector_profile_properties(
&mut object_166,
var_165,
)?;
object_166.finish();
}
if let Some(var_167) = &input.custom_connector {
#[allow(unused_mut)]
let mut object_168 = object.key("CustomConnector").start_object();
crate::json_ser::serialize_structure_crate_model_custom_connector_profile_properties(
&mut object_168,
var_167,
)?;
object_168.finish();
}
if let Some(var_169) = &input.pardot {
#[allow(unused_mut)]
let mut object_170 = object.key("Pardot").start_object();
crate::json_ser::serialize_structure_crate_model_pardot_connector_profile_properties(
&mut object_170,
var_169,
)?;
object_170.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_connector_profile_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConnectorProfileCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_171) = &input.amplitude {
#[allow(unused_mut)]
let mut object_172 = object.key("Amplitude").start_object();
crate::json_ser::serialize_structure_crate_model_amplitude_connector_profile_credentials(
&mut object_172,
var_171,
)?;
object_172.finish();
}
if let Some(var_173) = &input.datadog {
#[allow(unused_mut)]
let mut object_174 = object.key("Datadog").start_object();
crate::json_ser::serialize_structure_crate_model_datadog_connector_profile_credentials(
&mut object_174,
var_173,
)?;
object_174.finish();
}
if let Some(var_175) = &input.dynatrace {
#[allow(unused_mut)]
let mut object_176 = object.key("Dynatrace").start_object();
crate::json_ser::serialize_structure_crate_model_dynatrace_connector_profile_credentials(
&mut object_176,
var_175,
)?;
object_176.finish();
}
if let Some(var_177) = &input.google_analytics {
#[allow(unused_mut)]
let mut object_178 = object.key("GoogleAnalytics").start_object();
crate::json_ser::serialize_structure_crate_model_google_analytics_connector_profile_credentials(&mut object_178, var_177)?;
object_178.finish();
}
if let Some(var_179) = &input.honeycode {
#[allow(unused_mut)]
let mut object_180 = object.key("Honeycode").start_object();
crate::json_ser::serialize_structure_crate_model_honeycode_connector_profile_credentials(
&mut object_180,
var_179,
)?;
object_180.finish();
}
if let Some(var_181) = &input.infor_nexus {
#[allow(unused_mut)]
let mut object_182 = object.key("InforNexus").start_object();
crate::json_ser::serialize_structure_crate_model_infor_nexus_connector_profile_credentials(
&mut object_182,
var_181,
)?;
object_182.finish();
}
if let Some(var_183) = &input.marketo {
#[allow(unused_mut)]
let mut object_184 = object.key("Marketo").start_object();
crate::json_ser::serialize_structure_crate_model_marketo_connector_profile_credentials(
&mut object_184,
var_183,
)?;
object_184.finish();
}
if let Some(var_185) = &input.redshift {
#[allow(unused_mut)]
let mut object_186 = object.key("Redshift").start_object();
crate::json_ser::serialize_structure_crate_model_redshift_connector_profile_credentials(
&mut object_186,
var_185,
)?;
object_186.finish();
}
if let Some(var_187) = &input.salesforce {
#[allow(unused_mut)]
let mut object_188 = object.key("Salesforce").start_object();
crate::json_ser::serialize_structure_crate_model_salesforce_connector_profile_credentials(
&mut object_188,
var_187,
)?;
object_188.finish();
}
if let Some(var_189) = &input.service_now {
#[allow(unused_mut)]
let mut object_190 = object.key("ServiceNow").start_object();
crate::json_ser::serialize_structure_crate_model_service_now_connector_profile_credentials(
&mut object_190,
var_189,
)?;
object_190.finish();
}
if let Some(var_191) = &input.singular {
#[allow(unused_mut)]
let mut object_192 = object.key("Singular").start_object();
crate::json_ser::serialize_structure_crate_model_singular_connector_profile_credentials(
&mut object_192,
var_191,
)?;
object_192.finish();
}
if let Some(var_193) = &input.slack {
#[allow(unused_mut)]
let mut object_194 = object.key("Slack").start_object();
crate::json_ser::serialize_structure_crate_model_slack_connector_profile_credentials(
&mut object_194,
var_193,
)?;
object_194.finish();
}
if let Some(var_195) = &input.snowflake {
#[allow(unused_mut)]
let mut object_196 = object.key("Snowflake").start_object();
crate::json_ser::serialize_structure_crate_model_snowflake_connector_profile_credentials(
&mut object_196,
var_195,
)?;
object_196.finish();
}
if let Some(var_197) = &input.trendmicro {
#[allow(unused_mut)]
let mut object_198 = object.key("Trendmicro").start_object();
crate::json_ser::serialize_structure_crate_model_trendmicro_connector_profile_credentials(
&mut object_198,
var_197,
)?;
object_198.finish();
}
if let Some(var_199) = &input.veeva {
#[allow(unused_mut)]
let mut object_200 = object.key("Veeva").start_object();
crate::json_ser::serialize_structure_crate_model_veeva_connector_profile_credentials(
&mut object_200,
var_199,
)?;
object_200.finish();
}
if let Some(var_201) = &input.zendesk {
#[allow(unused_mut)]
let mut object_202 = object.key("Zendesk").start_object();
crate::json_ser::serialize_structure_crate_model_zendesk_connector_profile_credentials(
&mut object_202,
var_201,
)?;
object_202.finish();
}
if let Some(var_203) = &input.sapo_data {
#[allow(unused_mut)]
let mut object_204 = object.key("SAPOData").start_object();
crate::json_ser::serialize_structure_crate_model_sapo_data_connector_profile_credentials(
&mut object_204,
var_203,
)?;
object_204.finish();
}
if let Some(var_205) = &input.custom_connector {
#[allow(unused_mut)]
let mut object_206 = object.key("CustomConnector").start_object();
crate::json_ser::serialize_structure_crate_model_custom_connector_profile_credentials(
&mut object_206,
var_205,
)?;
object_206.finish();
}
if let Some(var_207) = &input.pardot {
#[allow(unused_mut)]
let mut object_208 = object.key("Pardot").start_object();
crate::json_ser::serialize_structure_crate_model_pardot_connector_profile_credentials(
&mut object_208,
var_207,
)?;
object_208.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_destination_connector_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DestinationConnectorProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_209) = &input.redshift {
#[allow(unused_mut)]
let mut object_210 = object.key("Redshift").start_object();
crate::json_ser::serialize_structure_crate_model_redshift_destination_properties(
&mut object_210,
var_209,
)?;
object_210.finish();
}
if let Some(var_211) = &input.s3 {
#[allow(unused_mut)]
let mut object_212 = object.key("S3").start_object();
crate::json_ser::serialize_structure_crate_model_s3_destination_properties(
&mut object_212,
var_211,
)?;
object_212.finish();
}
if let Some(var_213) = &input.salesforce {
#[allow(unused_mut)]
let mut object_214 = object.key("Salesforce").start_object();
crate::json_ser::serialize_structure_crate_model_salesforce_destination_properties(
&mut object_214,
var_213,
)?;
object_214.finish();
}
if let Some(var_215) = &input.snowflake {
#[allow(unused_mut)]
let mut object_216 = object.key("Snowflake").start_object();
crate::json_ser::serialize_structure_crate_model_snowflake_destination_properties(
&mut object_216,
var_215,
)?;
object_216.finish();
}
if let Some(var_217) = &input.event_bridge {
#[allow(unused_mut)]
let mut object_218 = object.key("EventBridge").start_object();
crate::json_ser::serialize_structure_crate_model_event_bridge_destination_properties(
&mut object_218,
var_217,
)?;
object_218.finish();
}
if let Some(var_219) = &input.lookout_metrics {
#[allow(unused_mut)]
let mut object_220 = object.key("LookoutMetrics").start_object();
crate::json_ser::serialize_structure_crate_model_lookout_metrics_destination_properties(
&mut object_220,
var_219,
)?;
object_220.finish();
}
if let Some(var_221) = &input.upsolver {
#[allow(unused_mut)]
let mut object_222 = object.key("Upsolver").start_object();
crate::json_ser::serialize_structure_crate_model_upsolver_destination_properties(
&mut object_222,
var_221,
)?;
object_222.finish();
}
if let Some(var_223) = &input.honeycode {
#[allow(unused_mut)]
let mut object_224 = object.key("Honeycode").start_object();
crate::json_ser::serialize_structure_crate_model_honeycode_destination_properties(
&mut object_224,
var_223,
)?;
object_224.finish();
}
if let Some(var_225) = &input.customer_profiles {
#[allow(unused_mut)]
let mut object_226 = object.key("CustomerProfiles").start_object();
crate::json_ser::serialize_structure_crate_model_customer_profiles_destination_properties(
&mut object_226,
var_225,
)?;
object_226.finish();
}
if let Some(var_227) = &input.zendesk {
#[allow(unused_mut)]
let mut object_228 = object.key("Zendesk").start_object();
crate::json_ser::serialize_structure_crate_model_zendesk_destination_properties(
&mut object_228,
var_227,
)?;
object_228.finish();
}
if let Some(var_229) = &input.marketo {
#[allow(unused_mut)]
let mut object_230 = object.key("Marketo").start_object();
crate::json_ser::serialize_structure_crate_model_marketo_destination_properties(
&mut object_230,
var_229,
)?;
object_230.finish();
}
if let Some(var_231) = &input.custom_connector {
#[allow(unused_mut)]
let mut object_232 = object.key("CustomConnector").start_object();
crate::json_ser::serialize_structure_crate_model_custom_connector_destination_properties(
&mut object_232,
var_231,
)?;
object_232.finish();
}
if let Some(var_233) = &input.sapo_data {
#[allow(unused_mut)]
let mut object_234 = object.key("SAPOData").start_object();
crate::json_ser::serialize_structure_crate_model_sapo_data_destination_properties(
&mut object_234,
var_233,
)?;
object_234.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_glue_data_catalog_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GlueDataCatalogConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_235) = &input.role_arn {
object.key("roleArn").string(var_235.as_str());
}
if let Some(var_236) = &input.database_name {
object.key("databaseName").string(var_236.as_str());
}
if let Some(var_237) = &input.table_prefix {
object.key("tablePrefix").string(var_237.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_source_connector_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SourceConnectorProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_238) = &input.amplitude {
#[allow(unused_mut)]
let mut object_239 = object.key("Amplitude").start_object();
crate::json_ser::serialize_structure_crate_model_amplitude_source_properties(
&mut object_239,
var_238,
)?;
object_239.finish();
}
if let Some(var_240) = &input.datadog {
#[allow(unused_mut)]
let mut object_241 = object.key("Datadog").start_object();
crate::json_ser::serialize_structure_crate_model_datadog_source_properties(
&mut object_241,
var_240,
)?;
object_241.finish();
}
if let Some(var_242) = &input.dynatrace {
#[allow(unused_mut)]
let mut object_243 = object.key("Dynatrace").start_object();
crate::json_ser::serialize_structure_crate_model_dynatrace_source_properties(
&mut object_243,
var_242,
)?;
object_243.finish();
}
if let Some(var_244) = &input.google_analytics {
#[allow(unused_mut)]
let mut object_245 = object.key("GoogleAnalytics").start_object();
crate::json_ser::serialize_structure_crate_model_google_analytics_source_properties(
&mut object_245,
var_244,
)?;
object_245.finish();
}
if let Some(var_246) = &input.infor_nexus {
#[allow(unused_mut)]
let mut object_247 = object.key("InforNexus").start_object();
crate::json_ser::serialize_structure_crate_model_infor_nexus_source_properties(
&mut object_247,
var_246,
)?;
object_247.finish();
}
if let Some(var_248) = &input.marketo {
#[allow(unused_mut)]
let mut object_249 = object.key("Marketo").start_object();
crate::json_ser::serialize_structure_crate_model_marketo_source_properties(
&mut object_249,
var_248,
)?;
object_249.finish();
}
if let Some(var_250) = &input.s3 {
#[allow(unused_mut)]
let mut object_251 = object.key("S3").start_object();
crate::json_ser::serialize_structure_crate_model_s3_source_properties(
&mut object_251,
var_250,
)?;
object_251.finish();
}
if let Some(var_252) = &input.salesforce {
#[allow(unused_mut)]
let mut object_253 = object.key("Salesforce").start_object();
crate::json_ser::serialize_structure_crate_model_salesforce_source_properties(
&mut object_253,
var_252,
)?;
object_253.finish();
}
if let Some(var_254) = &input.service_now {
#[allow(unused_mut)]
let mut object_255 = object.key("ServiceNow").start_object();
crate::json_ser::serialize_structure_crate_model_service_now_source_properties(
&mut object_255,
var_254,
)?;
object_255.finish();
}
if let Some(var_256) = &input.singular {
#[allow(unused_mut)]
let mut object_257 = object.key("Singular").start_object();
crate::json_ser::serialize_structure_crate_model_singular_source_properties(
&mut object_257,
var_256,
)?;
object_257.finish();
}
if let Some(var_258) = &input.slack {
#[allow(unused_mut)]
let mut object_259 = object.key("Slack").start_object();
crate::json_ser::serialize_structure_crate_model_slack_source_properties(
&mut object_259,
var_258,
)?;
object_259.finish();
}
if let Some(var_260) = &input.trendmicro {
#[allow(unused_mut)]
let mut object_261 = object.key("Trendmicro").start_object();
crate::json_ser::serialize_structure_crate_model_trendmicro_source_properties(
&mut object_261,
var_260,
)?;
object_261.finish();
}
if let Some(var_262) = &input.veeva {
#[allow(unused_mut)]
let mut object_263 = object.key("Veeva").start_object();
crate::json_ser::serialize_structure_crate_model_veeva_source_properties(
&mut object_263,
var_262,
)?;
object_263.finish();
}
if let Some(var_264) = &input.zendesk {
#[allow(unused_mut)]
let mut object_265 = object.key("Zendesk").start_object();
crate::json_ser::serialize_structure_crate_model_zendesk_source_properties(
&mut object_265,
var_264,
)?;
object_265.finish();
}
if let Some(var_266) = &input.sapo_data {
#[allow(unused_mut)]
let mut object_267 = object.key("SAPOData").start_object();
crate::json_ser::serialize_structure_crate_model_sapo_data_source_properties(
&mut object_267,
var_266,
)?;
object_267.finish();
}
if let Some(var_268) = &input.custom_connector {
#[allow(unused_mut)]
let mut object_269 = object.key("CustomConnector").start_object();
crate::json_ser::serialize_structure_crate_model_custom_connector_source_properties(
&mut object_269,
var_268,
)?;
object_269.finish();
}
if let Some(var_270) = &input.pardot {
#[allow(unused_mut)]
let mut object_271 = object.key("Pardot").start_object();
crate::json_ser::serialize_structure_crate_model_pardot_source_properties(
&mut object_271,
var_270,
)?;
object_271.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_incremental_pull_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IncrementalPullConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_272) = &input.datetime_type_field_name {
object.key("datetimeTypeFieldName").string(var_272.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_connector_operator(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConnectorOperator,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_273) = &input.amplitude {
object.key("Amplitude").string(var_273.as_str());
}
if let Some(var_274) = &input.datadog {
object.key("Datadog").string(var_274.as_str());
}
if let Some(var_275) = &input.dynatrace {
object.key("Dynatrace").string(var_275.as_str());
}
if let Some(var_276) = &input.google_analytics {
object.key("GoogleAnalytics").string(var_276.as_str());
}
if let Some(var_277) = &input.infor_nexus {
object.key("InforNexus").string(var_277.as_str());
}
if let Some(var_278) = &input.marketo {
object.key("Marketo").string(var_278.as_str());
}
if let Some(var_279) = &input.s3 {
object.key("S3").string(var_279.as_str());
}
if let Some(var_280) = &input.salesforce {
object.key("Salesforce").string(var_280.as_str());
}
if let Some(var_281) = &input.service_now {
object.key("ServiceNow").string(var_281.as_str());
}
if let Some(var_282) = &input.singular {
object.key("Singular").string(var_282.as_str());
}
if let Some(var_283) = &input.slack {
object.key("Slack").string(var_283.as_str());
}
if let Some(var_284) = &input.trendmicro {
object.key("Trendmicro").string(var_284.as_str());
}
if let Some(var_285) = &input.veeva {
object.key("Veeva").string(var_285.as_str());
}
if let Some(var_286) = &input.zendesk {
object.key("Zendesk").string(var_286.as_str());
}
if let Some(var_287) = &input.sapo_data {
object.key("SAPOData").string(var_287.as_str());
}
if let Some(var_288) = &input.custom_connector {
object.key("CustomConnector").string(var_288.as_str());
}
if let Some(var_289) = &input.pardot {
object.key("Pardot").string(var_289.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_trigger_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TriggerProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_290) = &input.scheduled {
#[allow(unused_mut)]
let mut object_291 = object.key("Scheduled").start_object();
crate::json_ser::serialize_structure_crate_model_scheduled_trigger_properties(
&mut object_291,
var_290,
)?;
object_291.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_lambda_connector_provisioning_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LambdaConnectorProvisioningConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_292) = &input.lambda_arn {
object.key("lambdaArn").string(var_292.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_amplitude_connector_profile_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AmplitudeConnectorProfileProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
let (_, _) = (object, input);
Ok(())
}
pub fn serialize_structure_crate_model_datadog_connector_profile_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatadogConnectorProfileProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_293) = &input.instance_url {
object.key("instanceUrl").string(var_293.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_dynatrace_connector_profile_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DynatraceConnectorProfileProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_294) = &input.instance_url {
object.key("instanceUrl").string(var_294.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_google_analytics_connector_profile_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GoogleAnalyticsConnectorProfileProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
let (_, _) = (object, input);
Ok(())
}
pub fn serialize_structure_crate_model_honeycode_connector_profile_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HoneycodeConnectorProfileProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
let (_, _) = (object, input);
Ok(())
}
pub fn serialize_structure_crate_model_infor_nexus_connector_profile_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InforNexusConnectorProfileProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_295) = &input.instance_url {
object.key("instanceUrl").string(var_295.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_marketo_connector_profile_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MarketoConnectorProfileProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_296) = &input.instance_url {
object.key("instanceUrl").string(var_296.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_redshift_connector_profile_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RedshiftConnectorProfileProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_297) = &input.database_url {
object.key("databaseUrl").string(var_297.as_str());
}
if let Some(var_298) = &input.bucket_name {
object.key("bucketName").string(var_298.as_str());
}
if let Some(var_299) = &input.bucket_prefix {
object.key("bucketPrefix").string(var_299.as_str());
}
if let Some(var_300) = &input.role_arn {
object.key("roleArn").string(var_300.as_str());
}
if let Some(var_301) = &input.data_api_role_arn {
object.key("dataApiRoleArn").string(var_301.as_str());
}
if input.is_redshift_serverless {
object
.key("isRedshiftServerless")
.boolean(input.is_redshift_serverless);
}
if let Some(var_302) = &input.cluster_identifier {
object.key("clusterIdentifier").string(var_302.as_str());
}
if let Some(var_303) = &input.workgroup_name {
object.key("workgroupName").string(var_303.as_str());
}
if let Some(var_304) = &input.database_name {
object.key("databaseName").string(var_304.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_salesforce_connector_profile_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SalesforceConnectorProfileProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_305) = &input.instance_url {
object.key("instanceUrl").string(var_305.as_str());
}
if input.is_sandbox_environment {
object
.key("isSandboxEnvironment")
.boolean(input.is_sandbox_environment);
}
Ok(())
}
pub fn serialize_structure_crate_model_service_now_connector_profile_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServiceNowConnectorProfileProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_306) = &input.instance_url {
object.key("instanceUrl").string(var_306.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_singular_connector_profile_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SingularConnectorProfileProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
let (_, _) = (object, input);
Ok(())
}
pub fn serialize_structure_crate_model_slack_connector_profile_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SlackConnectorProfileProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_307) = &input.instance_url {
object.key("instanceUrl").string(var_307.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_snowflake_connector_profile_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SnowflakeConnectorProfileProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_308) = &input.warehouse {
object.key("warehouse").string(var_308.as_str());
}
if let Some(var_309) = &input.stage {
object.key("stage").string(var_309.as_str());
}
if let Some(var_310) = &input.bucket_name {
object.key("bucketName").string(var_310.as_str());
}
if let Some(var_311) = &input.bucket_prefix {
object.key("bucketPrefix").string(var_311.as_str());
}
if let Some(var_312) = &input.private_link_service_name {
object
.key("privateLinkServiceName")
.string(var_312.as_str());
}
if let Some(var_313) = &input.account_name {
object.key("accountName").string(var_313.as_str());
}
if let Some(var_314) = &input.region {
object.key("region").string(var_314.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_trendmicro_connector_profile_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TrendmicroConnectorProfileProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
let (_, _) = (object, input);
Ok(())
}
pub fn serialize_structure_crate_model_veeva_connector_profile_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VeevaConnectorProfileProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_315) = &input.instance_url {
object.key("instanceUrl").string(var_315.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_zendesk_connector_profile_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ZendeskConnectorProfileProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_316) = &input.instance_url {
object.key("instanceUrl").string(var_316.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sapo_data_connector_profile_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SapoDataConnectorProfileProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_317) = &input.application_host_url {
object.key("applicationHostUrl").string(var_317.as_str());
}
if let Some(var_318) = &input.application_service_path {
object
.key("applicationServicePath")
.string(var_318.as_str());
}
if let Some(var_319) = &input.port_number {
object.key("portNumber").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_319).into()),
);
}
if let Some(var_320) = &input.client_number {
object.key("clientNumber").string(var_320.as_str());
}
if let Some(var_321) = &input.logon_language {
object.key("logonLanguage").string(var_321.as_str());
}
if let Some(var_322) = &input.private_link_service_name {
object
.key("privateLinkServiceName")
.string(var_322.as_str());
}
if let Some(var_323) = &input.o_auth_properties {
#[allow(unused_mut)]
let mut object_324 = object.key("oAuthProperties").start_object();
crate::json_ser::serialize_structure_crate_model_o_auth_properties(
&mut object_324,
var_323,
)?;
object_324.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_connector_profile_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomConnectorProfileProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_325) = &input.profile_properties {
#[allow(unused_mut)]
let mut object_326 = object.key("profileProperties").start_object();
for (key_327, value_328) in var_325 {
{
object_326.key(key_327.as_str()).string(value_328.as_str());
}
}
object_326.finish();
}
if let Some(var_329) = &input.o_auth2_properties {
#[allow(unused_mut)]
let mut object_330 = object.key("oAuth2Properties").start_object();
crate::json_ser::serialize_structure_crate_model_o_auth2_properties(
&mut object_330,
var_329,
)?;
object_330.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pardot_connector_profile_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PardotConnectorProfileProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_331) = &input.instance_url {
object.key("instanceUrl").string(var_331.as_str());
}
if input.is_sandbox_environment {
object
.key("isSandboxEnvironment")
.boolean(input.is_sandbox_environment);
}
if let Some(var_332) = &input.business_unit_id {
object.key("businessUnitId").string(var_332.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_amplitude_connector_profile_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AmplitudeConnectorProfileCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_333) = &input.api_key {
object.key("apiKey").string(var_333.as_str());
}
if let Some(var_334) = &input.secret_key {
object.key("secretKey").string(var_334.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_datadog_connector_profile_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatadogConnectorProfileCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_335) = &input.api_key {
object.key("apiKey").string(var_335.as_str());
}
if let Some(var_336) = &input.application_key {
object.key("applicationKey").string(var_336.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_dynatrace_connector_profile_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DynatraceConnectorProfileCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_337) = &input.api_token {
object.key("apiToken").string(var_337.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_google_analytics_connector_profile_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GoogleAnalyticsConnectorProfileCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_338) = &input.client_id {
object.key("clientId").string(var_338.as_str());
}
if let Some(var_339) = &input.client_secret {
object.key("clientSecret").string(var_339.as_str());
}
if let Some(var_340) = &input.access_token {
object.key("accessToken").string(var_340.as_str());
}
if let Some(var_341) = &input.refresh_token {
object.key("refreshToken").string(var_341.as_str());
}
if let Some(var_342) = &input.o_auth_request {
#[allow(unused_mut)]
let mut object_343 = object.key("oAuthRequest").start_object();
crate::json_ser::serialize_structure_crate_model_connector_o_auth_request(
&mut object_343,
var_342,
)?;
object_343.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_honeycode_connector_profile_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HoneycodeConnectorProfileCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_344) = &input.access_token {
object.key("accessToken").string(var_344.as_str());
}
if let Some(var_345) = &input.refresh_token {
object.key("refreshToken").string(var_345.as_str());
}
if let Some(var_346) = &input.o_auth_request {
#[allow(unused_mut)]
let mut object_347 = object.key("oAuthRequest").start_object();
crate::json_ser::serialize_structure_crate_model_connector_o_auth_request(
&mut object_347,
var_346,
)?;
object_347.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_infor_nexus_connector_profile_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InforNexusConnectorProfileCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_348) = &input.access_key_id {
object.key("accessKeyId").string(var_348.as_str());
}
if let Some(var_349) = &input.user_id {
object.key("userId").string(var_349.as_str());
}
if let Some(var_350) = &input.secret_access_key {
object.key("secretAccessKey").string(var_350.as_str());
}
if let Some(var_351) = &input.datakey {
object.key("datakey").string(var_351.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_marketo_connector_profile_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MarketoConnectorProfileCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_352) = &input.client_id {
object.key("clientId").string(var_352.as_str());
}
if let Some(var_353) = &input.client_secret {
object.key("clientSecret").string(var_353.as_str());
}
if let Some(var_354) = &input.access_token {
object.key("accessToken").string(var_354.as_str());
}
if let Some(var_355) = &input.o_auth_request {
#[allow(unused_mut)]
let mut object_356 = object.key("oAuthRequest").start_object();
crate::json_ser::serialize_structure_crate_model_connector_o_auth_request(
&mut object_356,
var_355,
)?;
object_356.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_redshift_connector_profile_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RedshiftConnectorProfileCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_357) = &input.username {
object.key("username").string(var_357.as_str());
}
if let Some(var_358) = &input.password {
object.key("password").string(var_358.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_salesforce_connector_profile_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SalesforceConnectorProfileCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_359) = &input.access_token {
object.key("accessToken").string(var_359.as_str());
}
if let Some(var_360) = &input.refresh_token {
object.key("refreshToken").string(var_360.as_str());
}
if let Some(var_361) = &input.o_auth_request {
#[allow(unused_mut)]
let mut object_362 = object.key("oAuthRequest").start_object();
crate::json_ser::serialize_structure_crate_model_connector_o_auth_request(
&mut object_362,
var_361,
)?;
object_362.finish();
}
if let Some(var_363) = &input.client_credentials_arn {
object.key("clientCredentialsArn").string(var_363.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_service_now_connector_profile_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServiceNowConnectorProfileCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_364) = &input.username {
object.key("username").string(var_364.as_str());
}
if let Some(var_365) = &input.password {
object.key("password").string(var_365.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_singular_connector_profile_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SingularConnectorProfileCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_366) = &input.api_key {
object.key("apiKey").string(var_366.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_slack_connector_profile_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SlackConnectorProfileCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_367) = &input.client_id {
object.key("clientId").string(var_367.as_str());
}
if let Some(var_368) = &input.client_secret {
object.key("clientSecret").string(var_368.as_str());
}
if let Some(var_369) = &input.access_token {
object.key("accessToken").string(var_369.as_str());
}
if let Some(var_370) = &input.o_auth_request {
#[allow(unused_mut)]
let mut object_371 = object.key("oAuthRequest").start_object();
crate::json_ser::serialize_structure_crate_model_connector_o_auth_request(
&mut object_371,
var_370,
)?;
object_371.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_snowflake_connector_profile_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SnowflakeConnectorProfileCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_372) = &input.username {
object.key("username").string(var_372.as_str());
}
if let Some(var_373) = &input.password {
object.key("password").string(var_373.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_trendmicro_connector_profile_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TrendmicroConnectorProfileCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_374) = &input.api_secret_key {
object.key("apiSecretKey").string(var_374.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_veeva_connector_profile_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VeevaConnectorProfileCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_375) = &input.username {
object.key("username").string(var_375.as_str());
}
if let Some(var_376) = &input.password {
object.key("password").string(var_376.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_zendesk_connector_profile_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ZendeskConnectorProfileCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_377) = &input.client_id {
object.key("clientId").string(var_377.as_str());
}
if let Some(var_378) = &input.client_secret {
object.key("clientSecret").string(var_378.as_str());
}
if let Some(var_379) = &input.access_token {
object.key("accessToken").string(var_379.as_str());
}
if let Some(var_380) = &input.o_auth_request {
#[allow(unused_mut)]
let mut object_381 = object.key("oAuthRequest").start_object();
crate::json_ser::serialize_structure_crate_model_connector_o_auth_request(
&mut object_381,
var_380,
)?;
object_381.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sapo_data_connector_profile_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SapoDataConnectorProfileCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_382) = &input.basic_auth_credentials {
#[allow(unused_mut)]
let mut object_383 = object.key("basicAuthCredentials").start_object();
crate::json_ser::serialize_structure_crate_model_basic_auth_credentials(
&mut object_383,
var_382,
)?;
object_383.finish();
}
if let Some(var_384) = &input.o_auth_credentials {
#[allow(unused_mut)]
let mut object_385 = object.key("oAuthCredentials").start_object();
crate::json_ser::serialize_structure_crate_model_o_auth_credentials(
&mut object_385,
var_384,
)?;
object_385.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_connector_profile_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomConnectorProfileCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_386) = &input.authentication_type {
object.key("authenticationType").string(var_386.as_str());
}
if let Some(var_387) = &input.basic {
#[allow(unused_mut)]
let mut object_388 = object.key("basic").start_object();
crate::json_ser::serialize_structure_crate_model_basic_auth_credentials(
&mut object_388,
var_387,
)?;
object_388.finish();
}
if let Some(var_389) = &input.oauth2 {
#[allow(unused_mut)]
let mut object_390 = object.key("oauth2").start_object();
crate::json_ser::serialize_structure_crate_model_o_auth2_credentials(
&mut object_390,
var_389,
)?;
object_390.finish();
}
if let Some(var_391) = &input.api_key {
#[allow(unused_mut)]
let mut object_392 = object.key("apiKey").start_object();
crate::json_ser::serialize_structure_crate_model_api_key_credentials(
&mut object_392,
var_391,
)?;
object_392.finish();
}
if let Some(var_393) = &input.custom {
#[allow(unused_mut)]
let mut object_394 = object.key("custom").start_object();
crate::json_ser::serialize_structure_crate_model_custom_auth_credentials(
&mut object_394,
var_393,
)?;
object_394.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pardot_connector_profile_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PardotConnectorProfileCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_395) = &input.access_token {
object.key("accessToken").string(var_395.as_str());
}
if let Some(var_396) = &input.refresh_token {
object.key("refreshToken").string(var_396.as_str());
}
if let Some(var_397) = &input.o_auth_request {
#[allow(unused_mut)]
let mut object_398 = object.key("oAuthRequest").start_object();
crate::json_ser::serialize_structure_crate_model_connector_o_auth_request(
&mut object_398,
var_397,
)?;
object_398.finish();
}
if let Some(var_399) = &input.client_credentials_arn {
object.key("clientCredentialsArn").string(var_399.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_redshift_destination_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RedshiftDestinationProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_400) = &input.object {
object.key("object").string(var_400.as_str());
}
if let Some(var_401) = &input.intermediate_bucket_name {
object
.key("intermediateBucketName")
.string(var_401.as_str());
}
if let Some(var_402) = &input.bucket_prefix {
object.key("bucketPrefix").string(var_402.as_str());
}
if let Some(var_403) = &input.error_handling_config {
#[allow(unused_mut)]
let mut object_404 = object.key("errorHandlingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_error_handling_config(
&mut object_404,
var_403,
)?;
object_404.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_destination_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3DestinationProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_405) = &input.bucket_name {
object.key("bucketName").string(var_405.as_str());
}
if let Some(var_406) = &input.bucket_prefix {
object.key("bucketPrefix").string(var_406.as_str());
}
if let Some(var_407) = &input.s3_output_format_config {
#[allow(unused_mut)]
let mut object_408 = object.key("s3OutputFormatConfig").start_object();
crate::json_ser::serialize_structure_crate_model_s3_output_format_config(
&mut object_408,
var_407,
)?;
object_408.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_salesforce_destination_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SalesforceDestinationProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_409) = &input.object {
object.key("object").string(var_409.as_str());
}
if let Some(var_410) = &input.id_field_names {
let mut array_411 = object.key("idFieldNames").start_array();
for item_412 in var_410 {
{
array_411.value().string(item_412.as_str());
}
}
array_411.finish();
}
if let Some(var_413) = &input.error_handling_config {
#[allow(unused_mut)]
let mut object_414 = object.key("errorHandlingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_error_handling_config(
&mut object_414,
var_413,
)?;
object_414.finish();
}
if let Some(var_415) = &input.write_operation_type {
object.key("writeOperationType").string(var_415.as_str());
}
if let Some(var_416) = &input.data_transfer_api {
object.key("dataTransferApi").string(var_416.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_snowflake_destination_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SnowflakeDestinationProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_417) = &input.object {
object.key("object").string(var_417.as_str());
}
if let Some(var_418) = &input.intermediate_bucket_name {
object
.key("intermediateBucketName")
.string(var_418.as_str());
}
if let Some(var_419) = &input.bucket_prefix {
object.key("bucketPrefix").string(var_419.as_str());
}
if let Some(var_420) = &input.error_handling_config {
#[allow(unused_mut)]
let mut object_421 = object.key("errorHandlingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_error_handling_config(
&mut object_421,
var_420,
)?;
object_421.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_event_bridge_destination_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EventBridgeDestinationProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_422) = &input.object {
object.key("object").string(var_422.as_str());
}
if let Some(var_423) = &input.error_handling_config {
#[allow(unused_mut)]
let mut object_424 = object.key("errorHandlingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_error_handling_config(
&mut object_424,
var_423,
)?;
object_424.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_lookout_metrics_destination_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LookoutMetricsDestinationProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
let (_, _) = (object, input);
Ok(())
}
pub fn serialize_structure_crate_model_upsolver_destination_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpsolverDestinationProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_425) = &input.bucket_name {
object.key("bucketName").string(var_425.as_str());
}
if let Some(var_426) = &input.bucket_prefix {
object.key("bucketPrefix").string(var_426.as_str());
}
if let Some(var_427) = &input.s3_output_format_config {
#[allow(unused_mut)]
let mut object_428 = object.key("s3OutputFormatConfig").start_object();
crate::json_ser::serialize_structure_crate_model_upsolver_s3_output_format_config(
&mut object_428,
var_427,
)?;
object_428.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_honeycode_destination_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HoneycodeDestinationProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_429) = &input.object {
object.key("object").string(var_429.as_str());
}
if let Some(var_430) = &input.error_handling_config {
#[allow(unused_mut)]
let mut object_431 = object.key("errorHandlingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_error_handling_config(
&mut object_431,
var_430,
)?;
object_431.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_customer_profiles_destination_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomerProfilesDestinationProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_432) = &input.domain_name {
object.key("domainName").string(var_432.as_str());
}
if let Some(var_433) = &input.object_type_name {
object.key("objectTypeName").string(var_433.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_zendesk_destination_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ZendeskDestinationProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_434) = &input.object {
object.key("object").string(var_434.as_str());
}
if let Some(var_435) = &input.id_field_names {
let mut array_436 = object.key("idFieldNames").start_array();
for item_437 in var_435 {
{
array_436.value().string(item_437.as_str());
}
}
array_436.finish();
}
if let Some(var_438) = &input.error_handling_config {
#[allow(unused_mut)]
let mut object_439 = object.key("errorHandlingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_error_handling_config(
&mut object_439,
var_438,
)?;
object_439.finish();
}
if let Some(var_440) = &input.write_operation_type {
object.key("writeOperationType").string(var_440.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_marketo_destination_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MarketoDestinationProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_441) = &input.object {
object.key("object").string(var_441.as_str());
}
if let Some(var_442) = &input.error_handling_config {
#[allow(unused_mut)]
let mut object_443 = object.key("errorHandlingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_error_handling_config(
&mut object_443,
var_442,
)?;
object_443.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_connector_destination_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomConnectorDestinationProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_444) = &input.entity_name {
object.key("entityName").string(var_444.as_str());
}
if let Some(var_445) = &input.error_handling_config {
#[allow(unused_mut)]
let mut object_446 = object.key("errorHandlingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_error_handling_config(
&mut object_446,
var_445,
)?;
object_446.finish();
}
if let Some(var_447) = &input.write_operation_type {
object.key("writeOperationType").string(var_447.as_str());
}
if let Some(var_448) = &input.id_field_names {
let mut array_449 = object.key("idFieldNames").start_array();
for item_450 in var_448 {
{
array_449.value().string(item_450.as_str());
}
}
array_449.finish();
}
if let Some(var_451) = &input.custom_properties {
#[allow(unused_mut)]
let mut object_452 = object.key("customProperties").start_object();
for (key_453, value_454) in var_451 {
{
object_452.key(key_453.as_str()).string(value_454.as_str());
}
}
object_452.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sapo_data_destination_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SapoDataDestinationProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_455) = &input.object_path {
object.key("objectPath").string(var_455.as_str());
}
if let Some(var_456) = &input.success_response_handling_config {
#[allow(unused_mut)]
let mut object_457 = object.key("successResponseHandlingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_success_response_handling_config(
&mut object_457,
var_456,
)?;
object_457.finish();
}
if let Some(var_458) = &input.id_field_names {
let mut array_459 = object.key("idFieldNames").start_array();
for item_460 in var_458 {
{
array_459.value().string(item_460.as_str());
}
}
array_459.finish();
}
if let Some(var_461) = &input.error_handling_config {
#[allow(unused_mut)]
let mut object_462 = object.key("errorHandlingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_error_handling_config(
&mut object_462,
var_461,
)?;
object_462.finish();
}
if let Some(var_463) = &input.write_operation_type {
object.key("writeOperationType").string(var_463.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_amplitude_source_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AmplitudeSourceProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_464) = &input.object {
object.key("object").string(var_464.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_datadog_source_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatadogSourceProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_465) = &input.object {
object.key("object").string(var_465.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_dynatrace_source_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DynatraceSourceProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_466) = &input.object {
object.key("object").string(var_466.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_google_analytics_source_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GoogleAnalyticsSourceProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_467) = &input.object {
object.key("object").string(var_467.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_infor_nexus_source_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InforNexusSourceProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_468) = &input.object {
object.key("object").string(var_468.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_marketo_source_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MarketoSourceProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_469) = &input.object {
object.key("object").string(var_469.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_source_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3SourceProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_470) = &input.bucket_name {
object.key("bucketName").string(var_470.as_str());
}
if let Some(var_471) = &input.bucket_prefix {
object.key("bucketPrefix").string(var_471.as_str());
}
if let Some(var_472) = &input.s3_input_format_config {
#[allow(unused_mut)]
let mut object_473 = object.key("s3InputFormatConfig").start_object();
crate::json_ser::serialize_structure_crate_model_s3_input_format_config(
&mut object_473,
var_472,
)?;
object_473.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_salesforce_source_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SalesforceSourceProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_474) = &input.object {
object.key("object").string(var_474.as_str());
}
if input.enable_dynamic_field_update {
object
.key("enableDynamicFieldUpdate")
.boolean(input.enable_dynamic_field_update);
}
if input.include_deleted_records {
object
.key("includeDeletedRecords")
.boolean(input.include_deleted_records);
}
if let Some(var_475) = &input.data_transfer_api {
object.key("dataTransferApi").string(var_475.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_service_now_source_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServiceNowSourceProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_476) = &input.object {
object.key("object").string(var_476.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_singular_source_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SingularSourceProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_477) = &input.object {
object.key("object").string(var_477.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_slack_source_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SlackSourceProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_478) = &input.object {
object.key("object").string(var_478.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_trendmicro_source_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TrendmicroSourceProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_479) = &input.object {
object.key("object").string(var_479.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_veeva_source_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VeevaSourceProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_480) = &input.object {
object.key("object").string(var_480.as_str());
}
if let Some(var_481) = &input.document_type {
object.key("documentType").string(var_481.as_str());
}
if input.include_source_files {
object
.key("includeSourceFiles")
.boolean(input.include_source_files);
}
if input.include_renditions {
object
.key("includeRenditions")
.boolean(input.include_renditions);
}
if input.include_all_versions {
object
.key("includeAllVersions")
.boolean(input.include_all_versions);
}
Ok(())
}
pub fn serialize_structure_crate_model_zendesk_source_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ZendeskSourceProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_482) = &input.object {
object.key("object").string(var_482.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sapo_data_source_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SapoDataSourceProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_483) = &input.object_path {
object.key("objectPath").string(var_483.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_connector_source_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomConnectorSourceProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_484) = &input.entity_name {
object.key("entityName").string(var_484.as_str());
}
if let Some(var_485) = &input.custom_properties {
#[allow(unused_mut)]
let mut object_486 = object.key("customProperties").start_object();
for (key_487, value_488) in var_485 {
{
object_486.key(key_487.as_str()).string(value_488.as_str());
}
}
object_486.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pardot_source_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PardotSourceProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_489) = &input.object {
object.key("object").string(var_489.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_scheduled_trigger_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ScheduledTriggerProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_490) = &input.schedule_expression {
object.key("scheduleExpression").string(var_490.as_str());
}
if let Some(var_491) = &input.data_pull_mode {
object.key("dataPullMode").string(var_491.as_str());
}
if let Some(var_492) = &input.schedule_start_time {
object
.key("scheduleStartTime")
.date_time(var_492, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_493) = &input.schedule_end_time {
object
.key("scheduleEndTime")
.date_time(var_493, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_494) = &input.timezone {
object.key("timezone").string(var_494.as_str());
}
if let Some(var_495) = &input.schedule_offset {
object.key("scheduleOffset").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_495).into()),
);
}
if let Some(var_496) = &input.first_execution_from {
object
.key("firstExecutionFrom")
.date_time(var_496, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_497) = &input.flow_error_deactivation_threshold {
object.key("flowErrorDeactivationThreshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_497).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_o_auth_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OAuthProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_498) = &input.token_url {
object.key("tokenUrl").string(var_498.as_str());
}
if let Some(var_499) = &input.auth_code_url {
object.key("authCodeUrl").string(var_499.as_str());
}
if let Some(var_500) = &input.o_auth_scopes {
let mut array_501 = object.key("oAuthScopes").start_array();
for item_502 in var_500 {
{
array_501.value().string(item_502.as_str());
}
}
array_501.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_o_auth2_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OAuth2Properties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_503) = &input.token_url {
object.key("tokenUrl").string(var_503.as_str());
}
if let Some(var_504) = &input.o_auth2_grant_type {
object.key("oAuth2GrantType").string(var_504.as_str());
}
if let Some(var_505) = &input.token_url_custom_properties {
#[allow(unused_mut)]
let mut object_506 = object.key("tokenUrlCustomProperties").start_object();
for (key_507, value_508) in var_505 {
{
object_506.key(key_507.as_str()).string(value_508.as_str());
}
}
object_506.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_connector_o_auth_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConnectorOAuthRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_509) = &input.auth_code {
object.key("authCode").string(var_509.as_str());
}
if let Some(var_510) = &input.redirect_uri {
object.key("redirectUri").string(var_510.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_basic_auth_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BasicAuthCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_511) = &input.username {
object.key("username").string(var_511.as_str());
}
if let Some(var_512) = &input.password {
object.key("password").string(var_512.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_o_auth_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OAuthCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_513) = &input.client_id {
object.key("clientId").string(var_513.as_str());
}
if let Some(var_514) = &input.client_secret {
object.key("clientSecret").string(var_514.as_str());
}
if let Some(var_515) = &input.access_token {
object.key("accessToken").string(var_515.as_str());
}
if let Some(var_516) = &input.refresh_token {
object.key("refreshToken").string(var_516.as_str());
}
if let Some(var_517) = &input.o_auth_request {
#[allow(unused_mut)]
let mut object_518 = object.key("oAuthRequest").start_object();
crate::json_ser::serialize_structure_crate_model_connector_o_auth_request(
&mut object_518,
var_517,
)?;
object_518.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_o_auth2_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OAuth2Credentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_519) = &input.client_id {
object.key("clientId").string(var_519.as_str());
}
if let Some(var_520) = &input.client_secret {
object.key("clientSecret").string(var_520.as_str());
}
if let Some(var_521) = &input.access_token {
object.key("accessToken").string(var_521.as_str());
}
if let Some(var_522) = &input.refresh_token {
object.key("refreshToken").string(var_522.as_str());
}
if let Some(var_523) = &input.o_auth_request {
#[allow(unused_mut)]
let mut object_524 = object.key("oAuthRequest").start_object();
crate::json_ser::serialize_structure_crate_model_connector_o_auth_request(
&mut object_524,
var_523,
)?;
object_524.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_api_key_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ApiKeyCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_525) = &input.api_key {
object.key("apiKey").string(var_525.as_str());
}
if let Some(var_526) = &input.api_secret_key {
object.key("apiSecretKey").string(var_526.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_auth_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomAuthCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_527) = &input.custom_authentication_type {
object
.key("customAuthenticationType")
.string(var_527.as_str());
}
if let Some(var_528) = &input.credentials_map {
#[allow(unused_mut)]
let mut object_529 = object.key("credentialsMap").start_object();
for (key_530, value_531) in var_528 {
{
object_529.key(key_530.as_str()).string(value_531.as_str());
}
}
object_529.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_error_handling_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ErrorHandlingConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.fail_on_first_destination_error {
object
.key("failOnFirstDestinationError")
.boolean(input.fail_on_first_destination_error);
}
if let Some(var_532) = &input.bucket_prefix {
object.key("bucketPrefix").string(var_532.as_str());
}
if let Some(var_533) = &input.bucket_name {
object.key("bucketName").string(var_533.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_output_format_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3OutputFormatConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_534) = &input.file_type {
object.key("fileType").string(var_534.as_str());
}
if let Some(var_535) = &input.prefix_config {
#[allow(unused_mut)]
let mut object_536 = object.key("prefixConfig").start_object();
crate::json_ser::serialize_structure_crate_model_prefix_config(&mut object_536, var_535)?;
object_536.finish();
}
if let Some(var_537) = &input.aggregation_config {
#[allow(unused_mut)]
let mut object_538 = object.key("aggregationConfig").start_object();
crate::json_ser::serialize_structure_crate_model_aggregation_config(
&mut object_538,
var_537,
)?;
object_538.finish();
}
if let Some(var_539) = &input.preserve_source_data_typing {
object.key("preserveSourceDataTyping").boolean(*var_539);
}
Ok(())
}
pub fn serialize_structure_crate_model_upsolver_s3_output_format_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpsolverS3OutputFormatConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_540) = &input.file_type {
object.key("fileType").string(var_540.as_str());
}
if let Some(var_541) = &input.prefix_config {
#[allow(unused_mut)]
let mut object_542 = object.key("prefixConfig").start_object();
crate::json_ser::serialize_structure_crate_model_prefix_config(&mut object_542, var_541)?;
object_542.finish();
}
if let Some(var_543) = &input.aggregation_config {
#[allow(unused_mut)]
let mut object_544 = object.key("aggregationConfig").start_object();
crate::json_ser::serialize_structure_crate_model_aggregation_config(
&mut object_544,
var_543,
)?;
object_544.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_success_response_handling_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SuccessResponseHandlingConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_545) = &input.bucket_prefix {
object.key("bucketPrefix").string(var_545.as_str());
}
if let Some(var_546) = &input.bucket_name {
object.key("bucketName").string(var_546.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_input_format_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3InputFormatConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_547) = &input.s3_input_file_type {
object.key("s3InputFileType").string(var_547.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_prefix_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PrefixConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_548) = &input.prefix_type {
object.key("prefixType").string(var_548.as_str());
}
if let Some(var_549) = &input.prefix_format {
object.key("prefixFormat").string(var_549.as_str());
}
if let Some(var_550) = &input.path_prefix_hierarchy {
let mut array_551 = object.key("pathPrefixHierarchy").start_array();
for item_552 in var_550 {
{
array_551.value().string(item_552.as_str());
}
}
array_551.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aggregation_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AggregationConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_553) = &input.aggregation_type {
object.key("aggregationType").string(var_553.as_str());
}
if let Some(var_554) = &input.target_file_size {
object.key("targetFileSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_554).into()),
);
}
Ok(())
}