pub fn serialize_structure_crate_input_clone_backend_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CloneBackendInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.target_environment_name {
object.key("targetEnvironmentName").string(var_1.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_backend_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBackendInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2) = &input.app_id {
object.key("appId").string(var_2.as_str());
}
if let Some(var_3) = &input.app_name {
object.key("appName").string(var_3.as_str());
}
if let Some(var_4) = &input.backend_environment_name {
object.key("backendEnvironmentName").string(var_4.as_str());
}
if let Some(var_5) = &input.resource_config {
#[allow(unused_mut)]
let mut object_6 = object.key("resourceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_resource_config(&mut object_6, var_5)?;
object_6.finish();
}
if let Some(var_7) = &input.resource_name {
object.key("resourceName").string(var_7.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_backend_api_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBackendApiInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_8) = &input.backend_environment_name {
object.key("backendEnvironmentName").string(var_8.as_str());
}
if let Some(var_9) = &input.resource_config {
#[allow(unused_mut)]
let mut object_10 = object.key("resourceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_backend_api_resource_config(
&mut object_10,
var_9,
)?;
object_10.finish();
}
if let Some(var_11) = &input.resource_name {
object.key("resourceName").string(var_11.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_backend_auth_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBackendAuthInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_12) = &input.backend_environment_name {
object.key("backendEnvironmentName").string(var_12.as_str());
}
if let Some(var_13) = &input.resource_config {
#[allow(unused_mut)]
let mut object_14 = object.key("resourceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_create_backend_auth_resource_config(
&mut object_14,
var_13,
)?;
object_14.finish();
}
if let Some(var_15) = &input.resource_name {
object.key("resourceName").string(var_15.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_backend_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBackendConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_16) = &input.backend_manager_app_id {
object.key("backendManagerAppId").string(var_16.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_backend_storage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBackendStorageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_17) = &input.backend_environment_name {
object.key("backendEnvironmentName").string(var_17.as_str());
}
if let Some(var_18) = &input.resource_config {
#[allow(unused_mut)]
let mut object_19 = object.key("resourceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_create_backend_storage_resource_config(
&mut object_19,
var_18,
)?;
object_19.finish();
}
if let Some(var_20) = &input.resource_name {
object.key("resourceName").string(var_20.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_backend_api_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteBackendApiInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_21) = &input.resource_config {
#[allow(unused_mut)]
let mut object_22 = object.key("resourceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_backend_api_resource_config(
&mut object_22,
var_21,
)?;
object_22.finish();
}
if let Some(var_23) = &input.resource_name {
object.key("resourceName").string(var_23.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_backend_auth_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteBackendAuthInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_24) = &input.resource_name {
object.key("resourceName").string(var_24.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_backend_storage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteBackendStorageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_25) = &input.resource_name {
object.key("resourceName").string(var_25.as_str());
}
if let Some(var_26) = &input.service_name {
object.key("serviceName").string(var_26.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_generate_backend_api_models_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GenerateBackendApiModelsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_27) = &input.resource_name {
object.key("resourceName").string(var_27.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_backend_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetBackendInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_28) = &input.backend_environment_name {
object.key("backendEnvironmentName").string(var_28.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_backend_api_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetBackendApiInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_29) = &input.resource_config {
#[allow(unused_mut)]
let mut object_30 = object.key("resourceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_backend_api_resource_config(
&mut object_30,
var_29,
)?;
object_30.finish();
}
if let Some(var_31) = &input.resource_name {
object.key("resourceName").string(var_31.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_backend_api_models_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetBackendApiModelsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_32) = &input.resource_name {
object.key("resourceName").string(var_32.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_backend_auth_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetBackendAuthInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_33) = &input.resource_name {
object.key("resourceName").string(var_33.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_backend_storage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetBackendStorageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_34) = &input.resource_name {
object.key("resourceName").string(var_34.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_import_backend_auth_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ImportBackendAuthInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_35) = &input.identity_pool_id {
object.key("identityPoolId").string(var_35.as_str());
}
if let Some(var_36) = &input.native_client_id {
object.key("nativeClientId").string(var_36.as_str());
}
if let Some(var_37) = &input.user_pool_id {
object.key("userPoolId").string(var_37.as_str());
}
if let Some(var_38) = &input.web_client_id {
object.key("webClientId").string(var_38.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_import_backend_storage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ImportBackendStorageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_39) = &input.bucket_name {
object.key("bucketName").string(var_39.as_str());
}
if let Some(var_40) = &input.service_name {
object.key("serviceName").string(var_40.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_backend_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListBackendJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_41) = &input.job_id {
object.key("jobId").string(var_41.as_str());
}
if input.max_results != 0 {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_42) = &input.next_token {
object.key("nextToken").string(var_42.as_str());
}
if let Some(var_43) = &input.operation {
object.key("operation").string(var_43.as_str());
}
if let Some(var_44) = &input.status {
object.key("status").string(var_44.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_s3_buckets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListS3BucketsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_45) = &input.next_token {
object.key("nextToken").string(var_45.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_remove_all_backends_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RemoveAllBackendsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.clean_amplify_app {
object
.key("cleanAmplifyApp")
.boolean(input.clean_amplify_app);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_backend_api_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateBackendApiInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_46) = &input.resource_config {
#[allow(unused_mut)]
let mut object_47 = object.key("resourceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_backend_api_resource_config(
&mut object_47,
var_46,
)?;
object_47.finish();
}
if let Some(var_48) = &input.resource_name {
object.key("resourceName").string(var_48.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_backend_auth_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateBackendAuthInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_49) = &input.resource_config {
#[allow(unused_mut)]
let mut object_50 = object.key("resourceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_update_backend_auth_resource_config(
&mut object_50,
var_49,
)?;
object_50.finish();
}
if let Some(var_51) = &input.resource_name {
object.key("resourceName").string(var_51.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_backend_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateBackendConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_52) = &input.login_auth_config {
#[allow(unused_mut)]
let mut object_53 = object.key("loginAuthConfig").start_object();
crate::json_ser::serialize_structure_crate_model_login_auth_config_req_obj(
&mut object_53,
var_52,
)?;
object_53.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_backend_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateBackendJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_54) = &input.operation {
object.key("operation").string(var_54.as_str());
}
if let Some(var_55) = &input.status {
object.key("status").string(var_55.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_backend_storage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateBackendStorageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_56) = &input.resource_config {
#[allow(unused_mut)]
let mut object_57 = object.key("resourceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_update_backend_storage_resource_config(
&mut object_57,
var_56,
)?;
object_57.finish();
}
if let Some(var_58) = &input.resource_name {
object.key("resourceName").string(var_58.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourceConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
let (_, _) = (object, input);
Ok(())
}
pub fn serialize_structure_crate_model_backend_api_resource_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BackendApiResourceConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_59) = &input.additional_auth_types {
let mut array_60 = object.key("additionalAuthTypes").start_array();
for item_61 in var_59 {
{
#[allow(unused_mut)]
let mut object_62 = array_60.value().start_object();
crate::json_ser::serialize_structure_crate_model_backend_api_auth_type(
&mut object_62,
item_61,
)?;
object_62.finish();
}
}
array_60.finish();
}
if let Some(var_63) = &input.api_name {
object.key("apiName").string(var_63.as_str());
}
if let Some(var_64) = &input.conflict_resolution {
#[allow(unused_mut)]
let mut object_65 = object.key("conflictResolution").start_object();
crate::json_ser::serialize_structure_crate_model_backend_api_conflict_resolution(
&mut object_65,
var_64,
)?;
object_65.finish();
}
if let Some(var_66) = &input.default_auth_type {
#[allow(unused_mut)]
let mut object_67 = object.key("defaultAuthType").start_object();
crate::json_ser::serialize_structure_crate_model_backend_api_auth_type(
&mut object_67,
var_66,
)?;
object_67.finish();
}
if let Some(var_68) = &input.service {
object.key("service").string(var_68.as_str());
}
if let Some(var_69) = &input.transform_schema {
object.key("transformSchema").string(var_69.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_create_backend_auth_resource_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateBackendAuthResourceConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_70) = &input.auth_resources {
object.key("authResources").string(var_70.as_str());
}
if let Some(var_71) = &input.identity_pool_configs {
#[allow(unused_mut)]
let mut object_72 = object.key("identityPoolConfigs").start_object();
crate::json_ser::serialize_structure_crate_model_create_backend_auth_identity_pool_config(
&mut object_72,
var_71,
)?;
object_72.finish();
}
if let Some(var_73) = &input.service {
object.key("service").string(var_73.as_str());
}
if let Some(var_74) = &input.user_pool_configs {
#[allow(unused_mut)]
let mut object_75 = object.key("userPoolConfigs").start_object();
crate::json_ser::serialize_structure_crate_model_create_backend_auth_user_pool_config(
&mut object_75,
var_74,
)?;
object_75.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_create_backend_storage_resource_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateBackendStorageResourceConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_76) = &input.bucket_name {
object.key("bucketName").string(var_76.as_str());
}
if let Some(var_77) = &input.permissions {
#[allow(unused_mut)]
let mut object_78 = object.key("permissions").start_object();
crate::json_ser::serialize_structure_crate_model_backend_storage_permissions(
&mut object_78,
var_77,
)?;
object_78.finish();
}
if let Some(var_79) = &input.service_name {
object.key("serviceName").string(var_79.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_update_backend_auth_resource_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateBackendAuthResourceConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_80) = &input.auth_resources {
object.key("authResources").string(var_80.as_str());
}
if let Some(var_81) = &input.identity_pool_configs {
#[allow(unused_mut)]
let mut object_82 = object.key("identityPoolConfigs").start_object();
crate::json_ser::serialize_structure_crate_model_update_backend_auth_identity_pool_config(
&mut object_82,
var_81,
)?;
object_82.finish();
}
if let Some(var_83) = &input.service {
object.key("service").string(var_83.as_str());
}
if let Some(var_84) = &input.user_pool_configs {
#[allow(unused_mut)]
let mut object_85 = object.key("userPoolConfigs").start_object();
crate::json_ser::serialize_structure_crate_model_update_backend_auth_user_pool_config(
&mut object_85,
var_84,
)?;
object_85.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_login_auth_config_req_obj(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoginAuthConfigReqObj,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_86) = &input.aws_cognito_identity_pool_id {
object
.key("aws_cognito_identity_pool_id")
.string(var_86.as_str());
}
if let Some(var_87) = &input.aws_cognito_region {
object.key("aws_cognito_region").string(var_87.as_str());
}
if let Some(var_88) = &input.aws_user_pools_id {
object.key("aws_user_pools_id").string(var_88.as_str());
}
if let Some(var_89) = &input.aws_user_pools_web_client_id {
object
.key("aws_user_pools_web_client_id")
.string(var_89.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_update_backend_storage_resource_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateBackendStorageResourceConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_90) = &input.permissions {
#[allow(unused_mut)]
let mut object_91 = object.key("permissions").start_object();
crate::json_ser::serialize_structure_crate_model_backend_storage_permissions(
&mut object_91,
var_90,
)?;
object_91.finish();
}
if let Some(var_92) = &input.service_name {
object.key("serviceName").string(var_92.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_backend_api_auth_type(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BackendApiAuthType,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_93) = &input.mode {
object.key("mode").string(var_93.as_str());
}
if let Some(var_94) = &input.settings {
#[allow(unused_mut)]
let mut object_95 = object.key("settings").start_object();
crate::json_ser::serialize_structure_crate_model_backend_api_app_sync_auth_settings(
&mut object_95,
var_94,
)?;
object_95.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_backend_api_conflict_resolution(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BackendApiConflictResolution,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_96) = &input.resolution_strategy {
object.key("resolutionStrategy").string(var_96.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_create_backend_auth_identity_pool_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateBackendAuthIdentityPoolConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_97) = &input.identity_pool_name {
object.key("identityPoolName").string(var_97.as_str());
}
{
object
.key("unauthenticatedLogin")
.boolean(input.unauthenticated_login);
}
Ok(())
}
pub fn serialize_structure_crate_model_create_backend_auth_user_pool_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateBackendAuthUserPoolConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_98) = &input.forgot_password {
#[allow(unused_mut)]
let mut object_99 = object.key("forgotPassword").start_object();
crate::json_ser::serialize_structure_crate_model_create_backend_auth_forgot_password_config(&mut object_99, var_98)?;
object_99.finish();
}
if let Some(var_100) = &input.mfa {
#[allow(unused_mut)]
let mut object_101 = object.key("mfa").start_object();
crate::json_ser::serialize_structure_crate_model_create_backend_auth_mfa_config(
&mut object_101,
var_100,
)?;
object_101.finish();
}
if let Some(var_102) = &input.o_auth {
#[allow(unused_mut)]
let mut object_103 = object.key("oAuth").start_object();
crate::json_ser::serialize_structure_crate_model_create_backend_auth_o_auth_config(
&mut object_103,
var_102,
)?;
object_103.finish();
}
if let Some(var_104) = &input.password_policy {
#[allow(unused_mut)]
let mut object_105 = object.key("passwordPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_create_backend_auth_password_policy_config(&mut object_105, var_104)?;
object_105.finish();
}
if let Some(var_106) = &input.required_sign_up_attributes {
let mut array_107 = object.key("requiredSignUpAttributes").start_array();
for item_108 in var_106 {
{
array_107.value().string(item_108.as_str());
}
}
array_107.finish();
}
if let Some(var_109) = &input.sign_in_method {
object.key("signInMethod").string(var_109.as_str());
}
if let Some(var_110) = &input.user_pool_name {
object.key("userPoolName").string(var_110.as_str());
}
if let Some(var_111) = &input.verification_message {
#[allow(unused_mut)]
let mut object_112 = object.key("verificationMessage").start_object();
crate::json_ser::serialize_structure_crate_model_create_backend_auth_verification_message_config(&mut object_112, var_111)?;
object_112.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_backend_storage_permissions(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BackendStoragePermissions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_113) = &input.authenticated {
let mut array_114 = object.key("authenticated").start_array();
for item_115 in var_113 {
{
array_114.value().string(item_115.as_str());
}
}
array_114.finish();
}
if let Some(var_116) = &input.un_authenticated {
let mut array_117 = object.key("unAuthenticated").start_array();
for item_118 in var_116 {
{
array_117.value().string(item_118.as_str());
}
}
array_117.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_update_backend_auth_identity_pool_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateBackendAuthIdentityPoolConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.unauthenticated_login {
object
.key("unauthenticatedLogin")
.boolean(input.unauthenticated_login);
}
Ok(())
}
pub fn serialize_structure_crate_model_update_backend_auth_user_pool_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateBackendAuthUserPoolConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_119) = &input.forgot_password {
#[allow(unused_mut)]
let mut object_120 = object.key("forgotPassword").start_object();
crate::json_ser::serialize_structure_crate_model_update_backend_auth_forgot_password_config(&mut object_120, var_119)?;
object_120.finish();
}
if let Some(var_121) = &input.mfa {
#[allow(unused_mut)]
let mut object_122 = object.key("mfa").start_object();
crate::json_ser::serialize_structure_crate_model_update_backend_auth_mfa_config(
&mut object_122,
var_121,
)?;
object_122.finish();
}
if let Some(var_123) = &input.o_auth {
#[allow(unused_mut)]
let mut object_124 = object.key("oAuth").start_object();
crate::json_ser::serialize_structure_crate_model_update_backend_auth_o_auth_config(
&mut object_124,
var_123,
)?;
object_124.finish();
}
if let Some(var_125) = &input.password_policy {
#[allow(unused_mut)]
let mut object_126 = object.key("passwordPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_update_backend_auth_password_policy_config(&mut object_126, var_125)?;
object_126.finish();
}
if let Some(var_127) = &input.verification_message {
#[allow(unused_mut)]
let mut object_128 = object.key("verificationMessage").start_object();
crate::json_ser::serialize_structure_crate_model_update_backend_auth_verification_message_config(&mut object_128, var_127)?;
object_128.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_backend_api_app_sync_auth_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BackendApiAppSyncAuthSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_129) = &input.cognito_user_pool_id {
object.key("cognitoUserPoolId").string(var_129.as_str());
}
if let Some(var_130) = &input.description {
object.key("description").string(var_130.as_str());
}
if input.expiration_time != 0.0 {
object.key("expirationTime").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.expiration_time).into()),
);
}
if let Some(var_131) = &input.open_id_auth_ttl {
object.key("openIDAuthTTL").string(var_131.as_str());
}
if let Some(var_132) = &input.open_id_client_id {
object.key("openIDClientId").string(var_132.as_str());
}
if let Some(var_133) = &input.open_id_iat_ttl {
object.key("openIDIatTTL").string(var_133.as_str());
}
if let Some(var_134) = &input.open_id_issue_url {
object.key("openIDIssueURL").string(var_134.as_str());
}
if let Some(var_135) = &input.open_id_provider_name {
object.key("openIDProviderName").string(var_135.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_create_backend_auth_forgot_password_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateBackendAuthForgotPasswordConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_136) = &input.delivery_method {
object.key("deliveryMethod").string(var_136.as_str());
}
if let Some(var_137) = &input.email_settings {
#[allow(unused_mut)]
let mut object_138 = object.key("emailSettings").start_object();
crate::json_ser::serialize_structure_crate_model_email_settings(&mut object_138, var_137)?;
object_138.finish();
}
if let Some(var_139) = &input.sms_settings {
#[allow(unused_mut)]
let mut object_140 = object.key("smsSettings").start_object();
crate::json_ser::serialize_structure_crate_model_sms_settings(&mut object_140, var_139)?;
object_140.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_create_backend_auth_mfa_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateBackendAuthMfaConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_141) = &input.mfa_mode {
object.key("MFAMode").string(var_141.as_str());
}
if let Some(var_142) = &input.settings {
#[allow(unused_mut)]
let mut object_143 = object.key("settings").start_object();
crate::json_ser::serialize_structure_crate_model_settings(&mut object_143, var_142)?;
object_143.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_create_backend_auth_o_auth_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateBackendAuthOAuthConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_144) = &input.domain_prefix {
object.key("domainPrefix").string(var_144.as_str());
}
if let Some(var_145) = &input.o_auth_grant_type {
object.key("oAuthGrantType").string(var_145.as_str());
}
if let Some(var_146) = &input.o_auth_scopes {
let mut array_147 = object.key("oAuthScopes").start_array();
for item_148 in var_146 {
{
array_147.value().string(item_148.as_str());
}
}
array_147.finish();
}
if let Some(var_149) = &input.redirect_sign_in_ur_is {
let mut array_150 = object.key("redirectSignInURIs").start_array();
for item_151 in var_149 {
{
array_150.value().string(item_151.as_str());
}
}
array_150.finish();
}
if let Some(var_152) = &input.redirect_sign_out_ur_is {
let mut array_153 = object.key("redirectSignOutURIs").start_array();
for item_154 in var_152 {
{
array_153.value().string(item_154.as_str());
}
}
array_153.finish();
}
if let Some(var_155) = &input.social_provider_settings {
#[allow(unused_mut)]
let mut object_156 = object.key("socialProviderSettings").start_object();
crate::json_ser::serialize_structure_crate_model_social_provider_settings(
&mut object_156,
var_155,
)?;
object_156.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_create_backend_auth_password_policy_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateBackendAuthPasswordPolicyConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_157) = &input.additional_constraints {
let mut array_158 = object.key("additionalConstraints").start_array();
for item_159 in var_157 {
{
array_158.value().string(item_159.as_str());
}
}
array_158.finish();
}
{
object.key("minimumLength").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.minimum_length).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_create_backend_auth_verification_message_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateBackendAuthVerificationMessageConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_160) = &input.delivery_method {
object.key("deliveryMethod").string(var_160.as_str());
}
if let Some(var_161) = &input.email_settings {
#[allow(unused_mut)]
let mut object_162 = object.key("emailSettings").start_object();
crate::json_ser::serialize_structure_crate_model_email_settings(&mut object_162, var_161)?;
object_162.finish();
}
if let Some(var_163) = &input.sms_settings {
#[allow(unused_mut)]
let mut object_164 = object.key("smsSettings").start_object();
crate::json_ser::serialize_structure_crate_model_sms_settings(&mut object_164, var_163)?;
object_164.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_update_backend_auth_forgot_password_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateBackendAuthForgotPasswordConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_165) = &input.delivery_method {
object.key("deliveryMethod").string(var_165.as_str());
}
if let Some(var_166) = &input.email_settings {
#[allow(unused_mut)]
let mut object_167 = object.key("emailSettings").start_object();
crate::json_ser::serialize_structure_crate_model_email_settings(&mut object_167, var_166)?;
object_167.finish();
}
if let Some(var_168) = &input.sms_settings {
#[allow(unused_mut)]
let mut object_169 = object.key("smsSettings").start_object();
crate::json_ser::serialize_structure_crate_model_sms_settings(&mut object_169, var_168)?;
object_169.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_update_backend_auth_mfa_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateBackendAuthMfaConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_170) = &input.mfa_mode {
object.key("MFAMode").string(var_170.as_str());
}
if let Some(var_171) = &input.settings {
#[allow(unused_mut)]
let mut object_172 = object.key("settings").start_object();
crate::json_ser::serialize_structure_crate_model_settings(&mut object_172, var_171)?;
object_172.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_update_backend_auth_o_auth_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateBackendAuthOAuthConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_173) = &input.domain_prefix {
object.key("domainPrefix").string(var_173.as_str());
}
if let Some(var_174) = &input.o_auth_grant_type {
object.key("oAuthGrantType").string(var_174.as_str());
}
if let Some(var_175) = &input.o_auth_scopes {
let mut array_176 = object.key("oAuthScopes").start_array();
for item_177 in var_175 {
{
array_176.value().string(item_177.as_str());
}
}
array_176.finish();
}
if let Some(var_178) = &input.redirect_sign_in_ur_is {
let mut array_179 = object.key("redirectSignInURIs").start_array();
for item_180 in var_178 {
{
array_179.value().string(item_180.as_str());
}
}
array_179.finish();
}
if let Some(var_181) = &input.redirect_sign_out_ur_is {
let mut array_182 = object.key("redirectSignOutURIs").start_array();
for item_183 in var_181 {
{
array_182.value().string(item_183.as_str());
}
}
array_182.finish();
}
if let Some(var_184) = &input.social_provider_settings {
#[allow(unused_mut)]
let mut object_185 = object.key("socialProviderSettings").start_object();
crate::json_ser::serialize_structure_crate_model_social_provider_settings(
&mut object_185,
var_184,
)?;
object_185.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_update_backend_auth_password_policy_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateBackendAuthPasswordPolicyConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_186) = &input.additional_constraints {
let mut array_187 = object.key("additionalConstraints").start_array();
for item_188 in var_186 {
{
array_187.value().string(item_188.as_str());
}
}
array_187.finish();
}
if input.minimum_length != 0.0 {
object.key("minimumLength").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.minimum_length).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_update_backend_auth_verification_message_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateBackendAuthVerificationMessageConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_189) = &input.delivery_method {
object.key("deliveryMethod").string(var_189.as_str());
}
if let Some(var_190) = &input.email_settings {
#[allow(unused_mut)]
let mut object_191 = object.key("emailSettings").start_object();
crate::json_ser::serialize_structure_crate_model_email_settings(&mut object_191, var_190)?;
object_191.finish();
}
if let Some(var_192) = &input.sms_settings {
#[allow(unused_mut)]
let mut object_193 = object.key("smsSettings").start_object();
crate::json_ser::serialize_structure_crate_model_sms_settings(&mut object_193, var_192)?;
object_193.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_email_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EmailSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_194) = &input.email_message {
object.key("emailMessage").string(var_194.as_str());
}
if let Some(var_195) = &input.email_subject {
object.key("emailSubject").string(var_195.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sms_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SmsSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_196) = &input.sms_message {
object.key("smsMessage").string(var_196.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Settings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_197) = &input.mfa_types {
let mut array_198 = object.key("mfaTypes").start_array();
for item_199 in var_197 {
{
array_198.value().string(item_199.as_str());
}
}
array_198.finish();
}
if let Some(var_200) = &input.sms_message {
object.key("smsMessage").string(var_200.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_social_provider_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SocialProviderSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_201) = &input.facebook {
#[allow(unused_mut)]
let mut object_202 = object.key("Facebook").start_object();
crate::json_ser::serialize_structure_crate_model_backend_auth_social_provider_config(
&mut object_202,
var_201,
)?;
object_202.finish();
}
if let Some(var_203) = &input.google {
#[allow(unused_mut)]
let mut object_204 = object.key("Google").start_object();
crate::json_ser::serialize_structure_crate_model_backend_auth_social_provider_config(
&mut object_204,
var_203,
)?;
object_204.finish();
}
if let Some(var_205) = &input.login_with_amazon {
#[allow(unused_mut)]
let mut object_206 = object.key("LoginWithAmazon").start_object();
crate::json_ser::serialize_structure_crate_model_backend_auth_social_provider_config(
&mut object_206,
var_205,
)?;
object_206.finish();
}
if let Some(var_207) = &input.sign_in_with_apple {
#[allow(unused_mut)]
let mut object_208 = object.key("SignInWithApple").start_object();
crate::json_ser::serialize_structure_crate_model_backend_auth_apple_provider_config(
&mut object_208,
var_207,
)?;
object_208.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_backend_auth_social_provider_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BackendAuthSocialProviderConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_209) = &input.client_id {
object.key("client_id").string(var_209.as_str());
}
if let Some(var_210) = &input.client_secret {
object.key("client_secret").string(var_210.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_backend_auth_apple_provider_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BackendAuthAppleProviderConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_211) = &input.client_id {
object.key("client_id").string(var_211.as_str());
}
if let Some(var_212) = &input.key_id {
object.key("key_id").string(var_212.as_str());
}
if let Some(var_213) = &input.private_key {
object.key("private_key").string(var_213.as_str());
}
if let Some(var_214) = &input.team_id {
object.key("team_id").string(var_214.as_str());
}
Ok(())
}