pub fn serialize_structure_crate_input_create_api_cache_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateApiCacheInput,
) {
if let Some(var_1) = &input.api_caching_behavior {
object.key("apiCachingBehavior").string(var_1.as_str());
}
if input.at_rest_encryption_enabled {
object
.key("atRestEncryptionEnabled")
.boolean(input.at_rest_encryption_enabled);
}
if input.transit_encryption_enabled {
object
.key("transitEncryptionEnabled")
.boolean(input.transit_encryption_enabled);
}
{
object.key("ttl").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.ttl).into()),
);
}
if let Some(var_2) = &input.r#type {
object.key("type").string(var_2.as_str());
}
}
pub fn serialize_structure_crate_input_create_api_key_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateApiKeyInput,
) {
if let Some(var_3) = &input.description {
object.key("description").string(var_3);
}
if input.expires != 0 {
object.key("expires").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.expires).into()),
);
}
}
pub fn serialize_structure_crate_input_create_data_source_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDataSourceInput,
) {
if let Some(var_4) = &input.description {
object.key("description").string(var_4);
}
if let Some(var_5) = &input.dynamodb_config {
let mut object_6 = object.key("dynamodbConfig").start_object();
crate::json_ser::serialize_structure_crate_model_dynamodb_data_source_config(
&mut object_6,
var_5,
);
object_6.finish();
}
if let Some(var_7) = &input.elasticsearch_config {
let mut object_8 = object.key("elasticsearchConfig").start_object();
crate::json_ser::serialize_structure_crate_model_elasticsearch_data_source_config(
&mut object_8,
var_7,
);
object_8.finish();
}
if let Some(var_9) = &input.http_config {
let mut object_10 = object.key("httpConfig").start_object();
crate::json_ser::serialize_structure_crate_model_http_data_source_config(
&mut object_10,
var_9,
);
object_10.finish();
}
if let Some(var_11) = &input.lambda_config {
let mut object_12 = object.key("lambdaConfig").start_object();
crate::json_ser::serialize_structure_crate_model_lambda_data_source_config(
&mut object_12,
var_11,
);
object_12.finish();
}
if let Some(var_13) = &input.name {
object.key("name").string(var_13);
}
if let Some(var_14) = &input.open_search_service_config {
let mut object_15 = object.key("openSearchServiceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_open_search_service_data_source_config(
&mut object_15,
var_14,
);
object_15.finish();
}
if let Some(var_16) = &input.relational_database_config {
let mut object_17 = object.key("relationalDatabaseConfig").start_object();
crate::json_ser::serialize_structure_crate_model_relational_database_data_source_config(
&mut object_17,
var_16,
);
object_17.finish();
}
if let Some(var_18) = &input.service_role_arn {
object.key("serviceRoleArn").string(var_18);
}
if let Some(var_19) = &input.r#type {
object.key("type").string(var_19.as_str());
}
}
pub fn serialize_structure_crate_input_create_function_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFunctionInput,
) {
if let Some(var_20) = &input.data_source_name {
object.key("dataSourceName").string(var_20);
}
if let Some(var_21) = &input.description {
object.key("description").string(var_21);
}
if let Some(var_22) = &input.function_version {
object.key("functionVersion").string(var_22);
}
if let Some(var_23) = &input.name {
object.key("name").string(var_23);
}
if let Some(var_24) = &input.request_mapping_template {
object.key("requestMappingTemplate").string(var_24);
}
if let Some(var_25) = &input.response_mapping_template {
object.key("responseMappingTemplate").string(var_25);
}
if let Some(var_26) = &input.sync_config {
let mut object_27 = object.key("syncConfig").start_object();
crate::json_ser::serialize_structure_crate_model_sync_config(&mut object_27, var_26);
object_27.finish();
}
}
pub fn serialize_structure_crate_input_create_graphql_api_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateGraphqlApiInput,
) {
if let Some(var_28) = &input.additional_authentication_providers {
let mut array_29 = object
.key("additionalAuthenticationProviders")
.start_array();
for item_30 in var_28 {
{
let mut object_31 = array_29.value().start_object();
crate::json_ser::serialize_structure_crate_model_additional_authentication_provider(
&mut object_31,
item_30,
);
object_31.finish();
}
}
array_29.finish();
}
if let Some(var_32) = &input.authentication_type {
object.key("authenticationType").string(var_32.as_str());
}
if let Some(var_33) = &input.lambda_authorizer_config {
let mut object_34 = object.key("lambdaAuthorizerConfig").start_object();
crate::json_ser::serialize_structure_crate_model_lambda_authorizer_config(
&mut object_34,
var_33,
);
object_34.finish();
}
if let Some(var_35) = &input.log_config {
let mut object_36 = object.key("logConfig").start_object();
crate::json_ser::serialize_structure_crate_model_log_config(&mut object_36, var_35);
object_36.finish();
}
if let Some(var_37) = &input.name {
object.key("name").string(var_37);
}
if let Some(var_38) = &input.open_id_connect_config {
let mut object_39 = object.key("openIDConnectConfig").start_object();
crate::json_ser::serialize_structure_crate_model_open_id_connect_config(
&mut object_39,
var_38,
);
object_39.finish();
}
if let Some(var_40) = &input.tags {
let mut object_41 = object.key("tags").start_object();
for (key_42, value_43) in var_40 {
{
object_41.key(key_42).string(value_43);
}
}
object_41.finish();
}
if let Some(var_44) = &input.user_pool_config {
let mut object_45 = object.key("userPoolConfig").start_object();
crate::json_ser::serialize_structure_crate_model_user_pool_config(&mut object_45, var_44);
object_45.finish();
}
if input.xray_enabled {
object.key("xrayEnabled").boolean(input.xray_enabled);
}
}
pub fn serialize_structure_crate_input_create_resolver_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateResolverInput,
) {
if let Some(var_46) = &input.caching_config {
let mut object_47 = object.key("cachingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_caching_config(&mut object_47, var_46);
object_47.finish();
}
if let Some(var_48) = &input.data_source_name {
object.key("dataSourceName").string(var_48);
}
if let Some(var_49) = &input.field_name {
object.key("fieldName").string(var_49);
}
if let Some(var_50) = &input.kind {
object.key("kind").string(var_50.as_str());
}
if let Some(var_51) = &input.pipeline_config {
let mut object_52 = object.key("pipelineConfig").start_object();
crate::json_ser::serialize_structure_crate_model_pipeline_config(&mut object_52, var_51);
object_52.finish();
}
if let Some(var_53) = &input.request_mapping_template {
object.key("requestMappingTemplate").string(var_53);
}
if let Some(var_54) = &input.response_mapping_template {
object.key("responseMappingTemplate").string(var_54);
}
if let Some(var_55) = &input.sync_config {
let mut object_56 = object.key("syncConfig").start_object();
crate::json_ser::serialize_structure_crate_model_sync_config(&mut object_56, var_55);
object_56.finish();
}
}
pub fn serialize_structure_crate_input_create_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateTypeInput,
) {
if let Some(var_57) = &input.definition {
object.key("definition").string(var_57);
}
if let Some(var_58) = &input.format {
object.key("format").string(var_58.as_str());
}
}
pub fn serialize_structure_crate_input_start_schema_creation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartSchemaCreationInput,
) {
if let Some(var_59) = &input.definition {
object
.key("definition")
.string_unchecked(&aws_smithy_types::base64::encode(var_59));
}
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) {
if let Some(var_60) = &input.tags {
let mut object_61 = object.key("tags").start_object();
for (key_62, value_63) in var_60 {
{
object_61.key(key_62).string(value_63);
}
}
object_61.finish();
}
}
pub fn serialize_structure_crate_input_update_api_cache_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateApiCacheInput,
) {
if let Some(var_64) = &input.api_caching_behavior {
object.key("apiCachingBehavior").string(var_64.as_str());
}
{
object.key("ttl").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.ttl).into()),
);
}
if let Some(var_65) = &input.r#type {
object.key("type").string(var_65.as_str());
}
}
pub fn serialize_structure_crate_input_update_api_key_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateApiKeyInput,
) {
if let Some(var_66) = &input.description {
object.key("description").string(var_66);
}
if input.expires != 0 {
object.key("expires").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.expires).into()),
);
}
}
pub fn serialize_structure_crate_input_update_data_source_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDataSourceInput,
) {
if let Some(var_67) = &input.description {
object.key("description").string(var_67);
}
if let Some(var_68) = &input.dynamodb_config {
let mut object_69 = object.key("dynamodbConfig").start_object();
crate::json_ser::serialize_structure_crate_model_dynamodb_data_source_config(
&mut object_69,
var_68,
);
object_69.finish();
}
if let Some(var_70) = &input.elasticsearch_config {
let mut object_71 = object.key("elasticsearchConfig").start_object();
crate::json_ser::serialize_structure_crate_model_elasticsearch_data_source_config(
&mut object_71,
var_70,
);
object_71.finish();
}
if let Some(var_72) = &input.http_config {
let mut object_73 = object.key("httpConfig").start_object();
crate::json_ser::serialize_structure_crate_model_http_data_source_config(
&mut object_73,
var_72,
);
object_73.finish();
}
if let Some(var_74) = &input.lambda_config {
let mut object_75 = object.key("lambdaConfig").start_object();
crate::json_ser::serialize_structure_crate_model_lambda_data_source_config(
&mut object_75,
var_74,
);
object_75.finish();
}
if let Some(var_76) = &input.open_search_service_config {
let mut object_77 = object.key("openSearchServiceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_open_search_service_data_source_config(
&mut object_77,
var_76,
);
object_77.finish();
}
if let Some(var_78) = &input.relational_database_config {
let mut object_79 = object.key("relationalDatabaseConfig").start_object();
crate::json_ser::serialize_structure_crate_model_relational_database_data_source_config(
&mut object_79,
var_78,
);
object_79.finish();
}
if let Some(var_80) = &input.service_role_arn {
object.key("serviceRoleArn").string(var_80);
}
if let Some(var_81) = &input.r#type {
object.key("type").string(var_81.as_str());
}
}
pub fn serialize_structure_crate_input_update_function_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFunctionInput,
) {
if let Some(var_82) = &input.data_source_name {
object.key("dataSourceName").string(var_82);
}
if let Some(var_83) = &input.description {
object.key("description").string(var_83);
}
if let Some(var_84) = &input.function_version {
object.key("functionVersion").string(var_84);
}
if let Some(var_85) = &input.name {
object.key("name").string(var_85);
}
if let Some(var_86) = &input.request_mapping_template {
object.key("requestMappingTemplate").string(var_86);
}
if let Some(var_87) = &input.response_mapping_template {
object.key("responseMappingTemplate").string(var_87);
}
if let Some(var_88) = &input.sync_config {
let mut object_89 = object.key("syncConfig").start_object();
crate::json_ser::serialize_structure_crate_model_sync_config(&mut object_89, var_88);
object_89.finish();
}
}
pub fn serialize_structure_crate_input_update_graphql_api_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateGraphqlApiInput,
) {
if let Some(var_90) = &input.additional_authentication_providers {
let mut array_91 = object
.key("additionalAuthenticationProviders")
.start_array();
for item_92 in var_90 {
{
let mut object_93 = array_91.value().start_object();
crate::json_ser::serialize_structure_crate_model_additional_authentication_provider(
&mut object_93,
item_92,
);
object_93.finish();
}
}
array_91.finish();
}
if let Some(var_94) = &input.authentication_type {
object.key("authenticationType").string(var_94.as_str());
}
if let Some(var_95) = &input.lambda_authorizer_config {
let mut object_96 = object.key("lambdaAuthorizerConfig").start_object();
crate::json_ser::serialize_structure_crate_model_lambda_authorizer_config(
&mut object_96,
var_95,
);
object_96.finish();
}
if let Some(var_97) = &input.log_config {
let mut object_98 = object.key("logConfig").start_object();
crate::json_ser::serialize_structure_crate_model_log_config(&mut object_98, var_97);
object_98.finish();
}
if let Some(var_99) = &input.name {
object.key("name").string(var_99);
}
if let Some(var_100) = &input.open_id_connect_config {
let mut object_101 = object.key("openIDConnectConfig").start_object();
crate::json_ser::serialize_structure_crate_model_open_id_connect_config(
&mut object_101,
var_100,
);
object_101.finish();
}
if let Some(var_102) = &input.user_pool_config {
let mut object_103 = object.key("userPoolConfig").start_object();
crate::json_ser::serialize_structure_crate_model_user_pool_config(&mut object_103, var_102);
object_103.finish();
}
if input.xray_enabled {
object.key("xrayEnabled").boolean(input.xray_enabled);
}
}
pub fn serialize_structure_crate_input_update_resolver_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateResolverInput,
) {
if let Some(var_104) = &input.caching_config {
let mut object_105 = object.key("cachingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_caching_config(&mut object_105, var_104);
object_105.finish();
}
if let Some(var_106) = &input.data_source_name {
object.key("dataSourceName").string(var_106);
}
if let Some(var_107) = &input.kind {
object.key("kind").string(var_107.as_str());
}
if let Some(var_108) = &input.pipeline_config {
let mut object_109 = object.key("pipelineConfig").start_object();
crate::json_ser::serialize_structure_crate_model_pipeline_config(&mut object_109, var_108);
object_109.finish();
}
if let Some(var_110) = &input.request_mapping_template {
object.key("requestMappingTemplate").string(var_110);
}
if let Some(var_111) = &input.response_mapping_template {
object.key("responseMappingTemplate").string(var_111);
}
if let Some(var_112) = &input.sync_config {
let mut object_113 = object.key("syncConfig").start_object();
crate::json_ser::serialize_structure_crate_model_sync_config(&mut object_113, var_112);
object_113.finish();
}
}
pub fn serialize_structure_crate_input_update_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateTypeInput,
) {
if let Some(var_114) = &input.definition {
object.key("definition").string(var_114);
}
if let Some(var_115) = &input.format {
object.key("format").string(var_115.as_str());
}
}
pub fn serialize_structure_crate_model_dynamodb_data_source_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DynamodbDataSourceConfig,
) {
if let Some(var_116) = &input.table_name {
object.key("tableName").string(var_116);
}
if let Some(var_117) = &input.aws_region {
object.key("awsRegion").string(var_117);
}
if input.use_caller_credentials {
object
.key("useCallerCredentials")
.boolean(input.use_caller_credentials);
}
if let Some(var_118) = &input.delta_sync_config {
let mut object_119 = object.key("deltaSyncConfig").start_object();
crate::json_ser::serialize_structure_crate_model_delta_sync_config(
&mut object_119,
var_118,
);
object_119.finish();
}
if input.versioned {
object.key("versioned").boolean(input.versioned);
}
}
pub fn serialize_structure_crate_model_elasticsearch_data_source_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ElasticsearchDataSourceConfig,
) {
if let Some(var_120) = &input.endpoint {
object.key("endpoint").string(var_120);
}
if let Some(var_121) = &input.aws_region {
object.key("awsRegion").string(var_121);
}
}
pub fn serialize_structure_crate_model_http_data_source_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HttpDataSourceConfig,
) {
if let Some(var_122) = &input.endpoint {
object.key("endpoint").string(var_122);
}
if let Some(var_123) = &input.authorization_config {
let mut object_124 = object.key("authorizationConfig").start_object();
crate::json_ser::serialize_structure_crate_model_authorization_config(
&mut object_124,
var_123,
);
object_124.finish();
}
}
pub fn serialize_structure_crate_model_lambda_data_source_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LambdaDataSourceConfig,
) {
if let Some(var_125) = &input.lambda_function_arn {
object.key("lambdaFunctionArn").string(var_125);
}
}
pub fn serialize_structure_crate_model_open_search_service_data_source_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OpenSearchServiceDataSourceConfig,
) {
if let Some(var_126) = &input.endpoint {
object.key("endpoint").string(var_126);
}
if let Some(var_127) = &input.aws_region {
object.key("awsRegion").string(var_127);
}
}
pub fn serialize_structure_crate_model_relational_database_data_source_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RelationalDatabaseDataSourceConfig,
) {
if let Some(var_128) = &input.relational_database_source_type {
object
.key("relationalDatabaseSourceType")
.string(var_128.as_str());
}
if let Some(var_129) = &input.rds_http_endpoint_config {
let mut object_130 = object.key("rdsHttpEndpointConfig").start_object();
crate::json_ser::serialize_structure_crate_model_rds_http_endpoint_config(
&mut object_130,
var_129,
);
object_130.finish();
}
}
pub fn serialize_structure_crate_model_sync_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SyncConfig,
) {
if let Some(var_131) = &input.conflict_handler {
object.key("conflictHandler").string(var_131.as_str());
}
if let Some(var_132) = &input.conflict_detection {
object.key("conflictDetection").string(var_132.as_str());
}
if let Some(var_133) = &input.lambda_conflict_handler_config {
let mut object_134 = object.key("lambdaConflictHandlerConfig").start_object();
crate::json_ser::serialize_structure_crate_model_lambda_conflict_handler_config(
&mut object_134,
var_133,
);
object_134.finish();
}
}
pub fn serialize_structure_crate_model_additional_authentication_provider(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AdditionalAuthenticationProvider,
) {
if let Some(var_135) = &input.authentication_type {
object.key("authenticationType").string(var_135.as_str());
}
if let Some(var_136) = &input.open_id_connect_config {
let mut object_137 = object.key("openIDConnectConfig").start_object();
crate::json_ser::serialize_structure_crate_model_open_id_connect_config(
&mut object_137,
var_136,
);
object_137.finish();
}
if let Some(var_138) = &input.user_pool_config {
let mut object_139 = object.key("userPoolConfig").start_object();
crate::json_ser::serialize_structure_crate_model_cognito_user_pool_config(
&mut object_139,
var_138,
);
object_139.finish();
}
if let Some(var_140) = &input.lambda_authorizer_config {
let mut object_141 = object.key("lambdaAuthorizerConfig").start_object();
crate::json_ser::serialize_structure_crate_model_lambda_authorizer_config(
&mut object_141,
var_140,
);
object_141.finish();
}
}
pub fn serialize_structure_crate_model_lambda_authorizer_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LambdaAuthorizerConfig,
) {
if input.authorizer_result_ttl_in_seconds != 0 {
object.key("authorizerResultTtlInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.authorizer_result_ttl_in_seconds).into()),
);
}
if let Some(var_142) = &input.authorizer_uri {
object.key("authorizerUri").string(var_142);
}
if let Some(var_143) = &input.identity_validation_expression {
object.key("identityValidationExpression").string(var_143);
}
}
pub fn serialize_structure_crate_model_log_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LogConfig,
) {
if let Some(var_144) = &input.field_log_level {
object.key("fieldLogLevel").string(var_144.as_str());
}
if let Some(var_145) = &input.cloud_watch_logs_role_arn {
object.key("cloudWatchLogsRoleArn").string(var_145);
}
if input.exclude_verbose_content {
object
.key("excludeVerboseContent")
.boolean(input.exclude_verbose_content);
}
}
pub fn serialize_structure_crate_model_open_id_connect_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OpenIdConnectConfig,
) {
if let Some(var_146) = &input.issuer {
object.key("issuer").string(var_146);
}
if let Some(var_147) = &input.client_id {
object.key("clientId").string(var_147);
}
if input.iat_ttl != 0 {
object.key("iatTTL").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.iat_ttl).into()),
);
}
if input.auth_ttl != 0 {
object.key("authTTL").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.auth_ttl).into()),
);
}
}
pub fn serialize_structure_crate_model_user_pool_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UserPoolConfig,
) {
if let Some(var_148) = &input.user_pool_id {
object.key("userPoolId").string(var_148);
}
if let Some(var_149) = &input.aws_region {
object.key("awsRegion").string(var_149);
}
if let Some(var_150) = &input.default_action {
object.key("defaultAction").string(var_150.as_str());
}
if let Some(var_151) = &input.app_id_client_regex {
object.key("appIdClientRegex").string(var_151);
}
}
pub fn serialize_structure_crate_model_caching_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CachingConfig,
) {
if input.ttl != 0 {
object.key("ttl").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.ttl).into()),
);
}
if let Some(var_152) = &input.caching_keys {
let mut array_153 = object.key("cachingKeys").start_array();
for item_154 in var_152 {
{
array_153.value().string(item_154);
}
}
array_153.finish();
}
}
pub fn serialize_structure_crate_model_pipeline_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipelineConfig,
) {
if let Some(var_155) = &input.functions {
let mut array_156 = object.key("functions").start_array();
for item_157 in var_155 {
{
array_156.value().string(item_157);
}
}
array_156.finish();
}
}
pub fn serialize_structure_crate_model_delta_sync_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeltaSyncConfig,
) {
if input.base_table_ttl != 0 {
object.key("baseTableTTL").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.base_table_ttl).into()),
);
}
if let Some(var_158) = &input.delta_sync_table_name {
object.key("deltaSyncTableName").string(var_158);
}
if input.delta_sync_table_ttl != 0 {
object.key("deltaSyncTableTTL").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.delta_sync_table_ttl).into()),
);
}
}
pub fn serialize_structure_crate_model_authorization_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AuthorizationConfig,
) {
if let Some(var_159) = &input.authorization_type {
object.key("authorizationType").string(var_159.as_str());
}
if let Some(var_160) = &input.aws_iam_config {
let mut object_161 = object.key("awsIamConfig").start_object();
crate::json_ser::serialize_structure_crate_model_aws_iam_config(&mut object_161, var_160);
object_161.finish();
}
}
pub fn serialize_structure_crate_model_rds_http_endpoint_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RdsHttpEndpointConfig,
) {
if let Some(var_162) = &input.aws_region {
object.key("awsRegion").string(var_162);
}
if let Some(var_163) = &input.db_cluster_identifier {
object.key("dbClusterIdentifier").string(var_163);
}
if let Some(var_164) = &input.database_name {
object.key("databaseName").string(var_164);
}
if let Some(var_165) = &input.schema {
object.key("schema").string(var_165);
}
if let Some(var_166) = &input.aws_secret_store_arn {
object.key("awsSecretStoreArn").string(var_166);
}
}
pub fn serialize_structure_crate_model_lambda_conflict_handler_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LambdaConflictHandlerConfig,
) {
if let Some(var_167) = &input.lambda_conflict_handler_arn {
object.key("lambdaConflictHandlerArn").string(var_167);
}
}
pub fn serialize_structure_crate_model_cognito_user_pool_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CognitoUserPoolConfig,
) {
if let Some(var_168) = &input.user_pool_id {
object.key("userPoolId").string(var_168);
}
if let Some(var_169) = &input.aws_region {
object.key("awsRegion").string(var_169);
}
if let Some(var_170) = &input.app_id_client_regex {
object.key("appIdClientRegex").string(var_170);
}
}
pub fn serialize_structure_crate_model_aws_iam_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsIamConfig,
) {
if let Some(var_171) = &input.signing_region {
object.key("signingRegion").string(var_171);
}
if let Some(var_172) = &input.signing_service_name {
object.key("signingServiceName").string(var_172);
}
}