rivet-identity 0.0.14

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
pub fn parse_http_generic_error(
	response: &http::Response<bytes::Bytes>,
) -> Result<aws_smithy_types::Error, aws_smithy_json::deserialize::Error> {
	crate::json_errors::parse_generic_error(response.body(), response.headers())
}

pub fn deser_structure_crate_error_internal_error_json_err(
	value: &[u8],
	mut builder: crate::error::internal_error::Builder,
) -> Result<crate::error::internal_error::Builder, aws_smithy_json::deserialize::Error> {
	let mut tokens_owned =
		aws_smithy_json::deserialize::json_token_iter(crate::json_deser::or_empty_doc(value))
			.peekable();
	let tokens = &mut tokens_owned;
	aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
	loop {
		match tokens.next().transpose()? {
			Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
			Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
				match key.to_unescaped()?.as_ref() {
					"code" => {
						builder = builder.set_code(
							aws_smithy_json::deserialize::token::expect_string_or_null(
								tokens.next(),
							)?
							.map(|s| s.to_unescaped().map(|u| u.into_owned()))
							.transpose()?,
						);
					}
					"message" => {
						builder = builder.set_message(
							aws_smithy_json::deserialize::token::expect_string_or_null(
								tokens.next(),
							)?
							.map(|s| s.to_unescaped().map(|u| u.into_owned()))
							.transpose()?,
						);
					}
					"metadata" => {
						builder = builder.set_metadata(Some(
							aws_smithy_json::deserialize::token::expect_document(tokens)?,
						));
					}
					_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
				}
			}
			other => {
				return Err(aws_smithy_json::deserialize::Error::custom(format!(
					"expected object key or end object, found: {:?}",
					other
				)))
			}
		}
	}
	if tokens.next().is_some() {
		return Err(aws_smithy_json::deserialize::Error::custom(
			"found more JSON tokens after completing parsing",
		));
	}
	Ok(builder)
}

pub fn deser_structure_crate_error_rate_limit_error_json_err(
	value: &[u8],
	mut builder: crate::error::rate_limit_error::Builder,
) -> Result<crate::error::rate_limit_error::Builder, aws_smithy_json::deserialize::Error> {
	let mut tokens_owned =
		aws_smithy_json::deserialize::json_token_iter(crate::json_deser::or_empty_doc(value))
			.peekable();
	let tokens = &mut tokens_owned;
	aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
	loop {
		match tokens.next().transpose()? {
			Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
			Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
				match key.to_unescaped()?.as_ref() {
					"code" => {
						builder = builder.set_code(
							aws_smithy_json::deserialize::token::expect_string_or_null(
								tokens.next(),
							)?
							.map(|s| s.to_unescaped().map(|u| u.into_owned()))
							.transpose()?,
						);
					}
					"message" => {
						builder = builder.set_message(
							aws_smithy_json::deserialize::token::expect_string_or_null(
								tokens.next(),
							)?
							.map(|s| s.to_unescaped().map(|u| u.into_owned()))
							.transpose()?,
						);
					}
					"metadata" => {
						builder = builder.set_metadata(Some(
							aws_smithy_json::deserialize::token::expect_document(tokens)?,
						));
					}
					_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
				}
			}
			other => {
				return Err(aws_smithy_json::deserialize::Error::custom(format!(
					"expected object key or end object, found: {:?}",
					other
				)))
			}
		}
	}
	if tokens.next().is_some() {
		return Err(aws_smithy_json::deserialize::Error::custom(
			"found more JSON tokens after completing parsing",
		));
	}
	Ok(builder)
}

pub fn deser_structure_crate_error_forbidden_error_json_err(
	value: &[u8],
	mut builder: crate::error::forbidden_error::Builder,
) -> Result<crate::error::forbidden_error::Builder, aws_smithy_json::deserialize::Error> {
	let mut tokens_owned =
		aws_smithy_json::deserialize::json_token_iter(crate::json_deser::or_empty_doc(value))
			.peekable();
	let tokens = &mut tokens_owned;
	aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
	loop {
		match tokens.next().transpose()? {
			Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
			Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
				match key.to_unescaped()?.as_ref() {
					"code" => {
						builder = builder.set_code(
							aws_smithy_json::deserialize::token::expect_string_or_null(
								tokens.next(),
							)?
							.map(|s| s.to_unescaped().map(|u| u.into_owned()))
							.transpose()?,
						);
					}
					"message" => {
						builder = builder.set_message(
							aws_smithy_json::deserialize::token::expect_string_or_null(
								tokens.next(),
							)?
							.map(|s| s.to_unescaped().map(|u| u.into_owned()))
							.transpose()?,
						);
					}
					"metadata" => {
						builder = builder.set_metadata(Some(
							aws_smithy_json::deserialize::token::expect_document(tokens)?,
						));
					}
					_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
				}
			}
			other => {
				return Err(aws_smithy_json::deserialize::Error::custom(format!(
					"expected object key or end object, found: {:?}",
					other
				)))
			}
		}
	}
	if tokens.next().is_some() {
		return Err(aws_smithy_json::deserialize::Error::custom(
			"found more JSON tokens after completing parsing",
		));
	}
	Ok(builder)
}

pub fn deser_structure_crate_error_unauthorized_error_json_err(
	value: &[u8],
	mut builder: crate::error::unauthorized_error::Builder,
) -> Result<crate::error::unauthorized_error::Builder, aws_smithy_json::deserialize::Error> {
	let mut tokens_owned =
		aws_smithy_json::deserialize::json_token_iter(crate::json_deser::or_empty_doc(value))
			.peekable();
	let tokens = &mut tokens_owned;
	aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
	loop {
		match tokens.next().transpose()? {
			Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
			Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
				match key.to_unescaped()?.as_ref() {
					"code" => {
						builder = builder.set_code(
							aws_smithy_json::deserialize::token::expect_string_or_null(
								tokens.next(),
							)?
							.map(|s| s.to_unescaped().map(|u| u.into_owned()))
							.transpose()?,
						);
					}
					"message" => {
						builder = builder.set_message(
							aws_smithy_json::deserialize::token::expect_string_or_null(
								tokens.next(),
							)?
							.map(|s| s.to_unescaped().map(|u| u.into_owned()))
							.transpose()?,
						);
					}
					"metadata" => {
						builder = builder.set_metadata(Some(
							aws_smithy_json::deserialize::token::expect_document(tokens)?,
						));
					}
					_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
				}
			}
			other => {
				return Err(aws_smithy_json::deserialize::Error::custom(format!(
					"expected object key or end object, found: {:?}",
					other
				)))
			}
		}
	}
	if tokens.next().is_some() {
		return Err(aws_smithy_json::deserialize::Error::custom(
			"found more JSON tokens after completing parsing",
		));
	}
	Ok(builder)
}

pub fn deser_structure_crate_error_not_found_error_json_err(
	value: &[u8],
	mut builder: crate::error::not_found_error::Builder,
) -> Result<crate::error::not_found_error::Builder, aws_smithy_json::deserialize::Error> {
	let mut tokens_owned =
		aws_smithy_json::deserialize::json_token_iter(crate::json_deser::or_empty_doc(value))
			.peekable();
	let tokens = &mut tokens_owned;
	aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
	loop {
		match tokens.next().transpose()? {
			Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
			Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
				match key.to_unescaped()?.as_ref() {
					"code" => {
						builder = builder.set_code(
							aws_smithy_json::deserialize::token::expect_string_or_null(
								tokens.next(),
							)?
							.map(|s| s.to_unescaped().map(|u| u.into_owned()))
							.transpose()?,
						);
					}
					"message" => {
						builder = builder.set_message(
							aws_smithy_json::deserialize::token::expect_string_or_null(
								tokens.next(),
							)?
							.map(|s| s.to_unescaped().map(|u| u.into_owned()))
							.transpose()?,
						);
					}
					"metadata" => {
						builder = builder.set_metadata(Some(
							aws_smithy_json::deserialize::token::expect_document(tokens)?,
						));
					}
					_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
				}
			}
			other => {
				return Err(aws_smithy_json::deserialize::Error::custom(format!(
					"expected object key or end object, found: {:?}",
					other
				)))
			}
		}
	}
	if tokens.next().is_some() {
		return Err(aws_smithy_json::deserialize::Error::custom(
			"found more JSON tokens after completing parsing",
		));
	}
	Ok(builder)
}

pub fn deser_structure_crate_error_bad_request_error_json_err(
	value: &[u8],
	mut builder: crate::error::bad_request_error::Builder,
) -> Result<crate::error::bad_request_error::Builder, aws_smithy_json::deserialize::Error> {
	let mut tokens_owned =
		aws_smithy_json::deserialize::json_token_iter(crate::json_deser::or_empty_doc(value))
			.peekable();
	let tokens = &mut tokens_owned;
	aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
	loop {
		match tokens.next().transpose()? {
			Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
			Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
				match key.to_unescaped()?.as_ref() {
					"code" => {
						builder = builder.set_code(
							aws_smithy_json::deserialize::token::expect_string_or_null(
								tokens.next(),
							)?
							.map(|s| s.to_unescaped().map(|u| u.into_owned()))
							.transpose()?,
						);
					}
					"message" => {
						builder = builder.set_message(
							aws_smithy_json::deserialize::token::expect_string_or_null(
								tokens.next(),
							)?
							.map(|s| s.to_unescaped().map(|u| u.into_owned()))
							.transpose()?,
						);
					}
					"metadata" => {
						builder = builder.set_metadata(Some(
							aws_smithy_json::deserialize::token::expect_document(tokens)?,
						));
					}
					_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
				}
			}
			other => {
				return Err(aws_smithy_json::deserialize::Error::custom(format!(
					"expected object key or end object, found: {:?}",
					other
				)))
			}
		}
	}
	if tokens.next().is_some() {
		return Err(aws_smithy_json::deserialize::Error::custom(
			"found more JSON tokens after completing parsing",
		));
	}
	Ok(builder)
}

pub fn deser_operation_crate_operation_get_game_link(
	value: &[u8],
	mut builder: crate::output::get_game_link_output::Builder,
) -> Result<crate::output::get_game_link_output::Builder, aws_smithy_json::deserialize::Error> {
	let mut tokens_owned =
		aws_smithy_json::deserialize::json_token_iter(crate::json_deser::or_empty_doc(value))
			.peekable();
	let tokens = &mut tokens_owned;
	aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
	loop {
		match tokens.next().transpose()? {
			Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
			Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
				match key.to_unescaped()?.as_ref() {
					"current_identity" => {
						builder = builder.set_current_identity(
							crate::json_deser::deser_structure_crate_model_identity_handle(tokens)?,
						);
					}
					"game" => {
						builder = builder.set_game(
							crate::json_deser::deser_structure_crate_model_game_handle(tokens)?,
						);
					}
					"new_identity" => {
						builder = builder.set_new_identity(
                            crate::json_deser::deser_structure_crate_model_get_game_link_new_identity(tokens)?
                        );
					}
					"status" => {
						builder = builder.set_status(
							aws_smithy_json::deserialize::token::expect_string_or_null(
								tokens.next(),
							)?
							.map(|s| {
								s.to_unescaped()
									.map(|u| crate::model::GameLinkStatus::from(u.as_ref()))
							})
							.transpose()?,
						);
					}
					"watch" => {
						builder = builder.set_watch(
							crate::json_deser::deser_structure_crate_model_watch_response(tokens)?,
						);
					}
					_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
				}
			}
			other => {
				return Err(aws_smithy_json::deserialize::Error::custom(format!(
					"expected object key or end object, found: {:?}",
					other
				)))
			}
		}
	}
	if tokens.next().is_some() {
		return Err(aws_smithy_json::deserialize::Error::custom(
			"found more JSON tokens after completing parsing",
		));
	}
	Ok(builder)
}

pub fn deser_operation_crate_operation_get_identity_handles(
	value: &[u8],
	mut builder: crate::output::get_identity_handles_output::Builder,
) -> Result<crate::output::get_identity_handles_output::Builder, aws_smithy_json::deserialize::Error>
{
	let mut tokens_owned =
		aws_smithy_json::deserialize::json_token_iter(crate::json_deser::or_empty_doc(value))
			.peekable();
	let tokens = &mut tokens_owned;
	aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
	loop {
		match tokens.next().transpose()? {
			Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
			Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
				match key.to_unescaped()?.as_ref() {
					"identities" => {
						builder = builder.set_identities(
							crate::json_deser::deser_list_rivet_identity_identity_handles(tokens)?,
						);
					}
					_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
				}
			}
			other => {
				return Err(aws_smithy_json::deserialize::Error::custom(format!(
					"expected object key or end object, found: {:?}",
					other
				)))
			}
		}
	}
	if tokens.next().is_some() {
		return Err(aws_smithy_json::deserialize::Error::custom(
			"found more JSON tokens after completing parsing",
		));
	}
	Ok(builder)
}

pub fn deser_operation_crate_operation_get_identity_profile(
	value: &[u8],
	mut builder: crate::output::get_identity_profile_output::Builder,
) -> Result<crate::output::get_identity_profile_output::Builder, aws_smithy_json::deserialize::Error>
{
	let mut tokens_owned =
		aws_smithy_json::deserialize::json_token_iter(crate::json_deser::or_empty_doc(value))
			.peekable();
	let tokens = &mut tokens_owned;
	aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
	loop {
		match tokens.next().transpose()? {
			Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
			Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
				match key.to_unescaped()?.as_ref() {
					"identity" => {
						builder = builder.set_identity(
							crate::json_deser::deser_structure_crate_model_identity_profile(
								tokens,
							)?,
						);
					}
					"watch" => {
						builder = builder.set_watch(
							crate::json_deser::deser_structure_crate_model_watch_response(tokens)?,
						);
					}
					_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
				}
			}
			other => {
				return Err(aws_smithy_json::deserialize::Error::custom(format!(
					"expected object key or end object, found: {:?}",
					other
				)))
			}
		}
	}
	if tokens.next().is_some() {
		return Err(aws_smithy_json::deserialize::Error::custom(
			"found more JSON tokens after completing parsing",
		));
	}
	Ok(builder)
}

pub fn deser_operation_crate_operation_get_identity_self_profile(
	value: &[u8],
	mut builder: crate::output::get_identity_self_profile_output::Builder,
) -> Result<
	crate::output::get_identity_self_profile_output::Builder,
	aws_smithy_json::deserialize::Error,
> {
	let mut tokens_owned =
		aws_smithy_json::deserialize::json_token_iter(crate::json_deser::or_empty_doc(value))
			.peekable();
	let tokens = &mut tokens_owned;
	aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
	loop {
		match tokens.next().transpose()? {
			Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
			Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
				match key.to_unescaped()?.as_ref() {
					"identity" => {
						builder = builder.set_identity(
							crate::json_deser::deser_structure_crate_model_identity_profile(
								tokens,
							)?,
						);
					}
					"watch" => {
						builder = builder.set_watch(
							crate::json_deser::deser_structure_crate_model_watch_response(tokens)?,
						);
					}
					_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
				}
			}
			other => {
				return Err(aws_smithy_json::deserialize::Error::custom(format!(
					"expected object key or end object, found: {:?}",
					other
				)))
			}
		}
	}
	if tokens.next().is_some() {
		return Err(aws_smithy_json::deserialize::Error::custom(
			"found more JSON tokens after completing parsing",
		));
	}
	Ok(builder)
}

pub fn deser_operation_crate_operation_get_identity_summaries(
	value: &[u8],
	mut builder: crate::output::get_identity_summaries_output::Builder,
) -> Result<
	crate::output::get_identity_summaries_output::Builder,
	aws_smithy_json::deserialize::Error,
> {
	let mut tokens_owned =
		aws_smithy_json::deserialize::json_token_iter(crate::json_deser::or_empty_doc(value))
			.peekable();
	let tokens = &mut tokens_owned;
	aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
	loop {
		match tokens.next().transpose()? {
			Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
			Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
				match key.to_unescaped()?.as_ref() {
					"identities" => {
						builder = builder.set_identities(
							crate::json_deser::deser_list_rivet_identity_identity_summaries(
								tokens,
							)?,
						);
					}
					_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
				}
			}
			other => {
				return Err(aws_smithy_json::deserialize::Error::custom(format!(
					"expected object key or end object, found: {:?}",
					other
				)))
			}
		}
	}
	if tokens.next().is_some() {
		return Err(aws_smithy_json::deserialize::Error::custom(
			"found more JSON tokens after completing parsing",
		));
	}
	Ok(builder)
}

pub fn deser_operation_crate_operation_list_activities(
	value: &[u8],
	mut builder: crate::output::list_activities_output::Builder,
) -> Result<crate::output::list_activities_output::Builder, aws_smithy_json::deserialize::Error> {
	let mut tokens_owned =
		aws_smithy_json::deserialize::json_token_iter(crate::json_deser::or_empty_doc(value))
			.peekable();
	let tokens = &mut tokens_owned;
	aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
	loop {
		match tokens.next().transpose()? {
			Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
			Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
				match key.to_unescaped()?.as_ref() {
					"games" => {
						builder = builder.set_games(
							crate::json_deser::deser_list_rivet_game_game_handles(tokens)?,
						);
					}
					"identities" => {
						builder = builder.set_identities(
							crate::json_deser::deser_list_rivet_identity_identity_handles(tokens)?,
						);
					}
					"parties" => {
						builder = builder.set_parties(
							crate::json_deser::deser_list_rivet_party_party_summaries(tokens)?,
						);
					}
					"suggested_groups" => {
						builder = builder.set_suggested_groups(
							crate::json_deser::deser_list_rivet_group_group_summaries(tokens)?,
						);
					}
					"suggested_players" => {
						builder = builder.set_suggested_players(
							crate::json_deser::deser_list_rivet_identity_identity_handles(tokens)?,
						);
					}
					"watch" => {
						builder = builder.set_watch(
							crate::json_deser::deser_structure_crate_model_watch_response(tokens)?,
						);
					}
					_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
				}
			}
			other => {
				return Err(aws_smithy_json::deserialize::Error::custom(format!(
					"expected object key or end object, found: {:?}",
					other
				)))
			}
		}
	}
	if tokens.next().is_some() {
		return Err(aws_smithy_json::deserialize::Error::custom(
			"found more JSON tokens after completing parsing",
		));
	}
	Ok(builder)
}

pub fn deser_operation_crate_operation_list_followers(
	value: &[u8],
	mut builder: crate::output::list_followers_output::Builder,
) -> Result<crate::output::list_followers_output::Builder, aws_smithy_json::deserialize::Error> {
	let mut tokens_owned =
		aws_smithy_json::deserialize::json_token_iter(crate::json_deser::or_empty_doc(value))
			.peekable();
	let tokens = &mut tokens_owned;
	aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
	loop {
		match tokens.next().transpose()? {
			Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
			Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
				match key.to_unescaped()?.as_ref() {
					"anchor" => {
						builder = builder.set_anchor(
							aws_smithy_json::deserialize::token::expect_string_or_null(
								tokens.next(),
							)?
							.map(|s| s.to_unescaped().map(|u| u.into_owned()))
							.transpose()?,
						);
					}
					"identities" => {
						builder = builder.set_identities(
							crate::json_deser::deser_list_rivet_identity_identity_handles(tokens)?,
						);
					}
					_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
				}
			}
			other => {
				return Err(aws_smithy_json::deserialize::Error::custom(format!(
					"expected object key or end object, found: {:?}",
					other
				)))
			}
		}
	}
	if tokens.next().is_some() {
		return Err(aws_smithy_json::deserialize::Error::custom(
			"found more JSON tokens after completing parsing",
		));
	}
	Ok(builder)
}

pub fn deser_operation_crate_operation_list_following(
	value: &[u8],
	mut builder: crate::output::list_following_output::Builder,
) -> Result<crate::output::list_following_output::Builder, aws_smithy_json::deserialize::Error> {
	let mut tokens_owned =
		aws_smithy_json::deserialize::json_token_iter(crate::json_deser::or_empty_doc(value))
			.peekable();
	let tokens = &mut tokens_owned;
	aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
	loop {
		match tokens.next().transpose()? {
			Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
			Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
				match key.to_unescaped()?.as_ref() {
					"anchor" => {
						builder = builder.set_anchor(
							aws_smithy_json::deserialize::token::expect_string_or_null(
								tokens.next(),
							)?
							.map(|s| s.to_unescaped().map(|u| u.into_owned()))
							.transpose()?,
						);
					}
					"identities" => {
						builder = builder.set_identities(
							crate::json_deser::deser_list_rivet_identity_identity_handles(tokens)?,
						);
					}
					_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
				}
			}
			other => {
				return Err(aws_smithy_json::deserialize::Error::custom(format!(
					"expected object key or end object, found: {:?}",
					other
				)))
			}
		}
	}
	if tokens.next().is_some() {
		return Err(aws_smithy_json::deserialize::Error::custom(
			"found more JSON tokens after completing parsing",
		));
	}
	Ok(builder)
}

pub fn deser_operation_crate_operation_list_friends(
	value: &[u8],
	mut builder: crate::output::list_friends_output::Builder,
) -> Result<crate::output::list_friends_output::Builder, aws_smithy_json::deserialize::Error> {
	let mut tokens_owned =
		aws_smithy_json::deserialize::json_token_iter(crate::json_deser::or_empty_doc(value))
			.peekable();
	let tokens = &mut tokens_owned;
	aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
	loop {
		match tokens.next().transpose()? {
			Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
			Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
				match key.to_unescaped()?.as_ref() {
					"anchor" => {
						builder = builder.set_anchor(
							aws_smithy_json::deserialize::token::expect_string_or_null(
								tokens.next(),
							)?
							.map(|s| s.to_unescaped().map(|u| u.into_owned()))
							.transpose()?,
						);
					}
					"identities" => {
						builder = builder.set_identities(
							crate::json_deser::deser_list_rivet_identity_identity_handles(tokens)?,
						);
					}
					_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
				}
			}
			other => {
				return Err(aws_smithy_json::deserialize::Error::custom(format!(
					"expected object key or end object, found: {:?}",
					other
				)))
			}
		}
	}
	if tokens.next().is_some() {
		return Err(aws_smithy_json::deserialize::Error::custom(
			"found more JSON tokens after completing parsing",
		));
	}
	Ok(builder)
}

pub fn deser_operation_crate_operation_list_mutual_friends(
	value: &[u8],
	mut builder: crate::output::list_mutual_friends_output::Builder,
) -> Result<crate::output::list_mutual_friends_output::Builder, aws_smithy_json::deserialize::Error>
{
	let mut tokens_owned =
		aws_smithy_json::deserialize::json_token_iter(crate::json_deser::or_empty_doc(value))
			.peekable();
	let tokens = &mut tokens_owned;
	aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
	loop {
		match tokens.next().transpose()? {
			Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
			Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
				match key.to_unescaped()?.as_ref() {
					"anchor" => {
						builder = builder.set_anchor(
							aws_smithy_json::deserialize::token::expect_string_or_null(
								tokens.next(),
							)?
							.map(|s| s.to_unescaped().map(|u| u.into_owned()))
							.transpose()?,
						);
					}
					"identities" => {
						builder = builder.set_identities(
							crate::json_deser::deser_list_rivet_identity_identity_handles(tokens)?,
						);
					}
					_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
				}
			}
			other => {
				return Err(aws_smithy_json::deserialize::Error::custom(format!(
					"expected object key or end object, found: {:?}",
					other
				)))
			}
		}
	}
	if tokens.next().is_some() {
		return Err(aws_smithy_json::deserialize::Error::custom(
			"found more JSON tokens after completing parsing",
		));
	}
	Ok(builder)
}

pub fn deser_operation_crate_operation_prepare_game_link(
	value: &[u8],
	mut builder: crate::output::prepare_game_link_output::Builder,
) -> Result<crate::output::prepare_game_link_output::Builder, aws_smithy_json::deserialize::Error> {
	let mut tokens_owned =
		aws_smithy_json::deserialize::json_token_iter(crate::json_deser::or_empty_doc(value))
			.peekable();
	let tokens = &mut tokens_owned;
	aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
	loop {
		match tokens.next().transpose()? {
			Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
			Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
				match key.to_unescaped()?.as_ref() {
					"expire_ts" => {
						builder = builder.set_expire_ts(
							aws_smithy_json::deserialize::token::expect_timestamp_or_null(
								tokens.next(),
								aws_smithy_types::date_time::Format::DateTime,
							)?,
						);
					}
					"identity_link_token" => {
						builder = builder.set_identity_link_token(
							aws_smithy_json::deserialize::token::expect_string_or_null(
								tokens.next(),
							)?
							.map(|s| s.to_unescaped().map(|u| u.into_owned()))
							.transpose()?,
						);
					}
					"identity_link_url" => {
						builder = builder.set_identity_link_url(
							aws_smithy_json::deserialize::token::expect_string_or_null(
								tokens.next(),
							)?
							.map(|s| s.to_unescaped().map(|u| u.into_owned()))
							.transpose()?,
						);
					}
					_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
				}
			}
			other => {
				return Err(aws_smithy_json::deserialize::Error::custom(format!(
					"expected object key or end object, found: {:?}",
					other
				)))
			}
		}
	}
	if tokens.next().is_some() {
		return Err(aws_smithy_json::deserialize::Error::custom(
			"found more JSON tokens after completing parsing",
		));
	}
	Ok(builder)
}

pub fn deser_operation_crate_operation_prepare_identity_avatar_upload(
	value: &[u8],
	mut builder: crate::output::prepare_identity_avatar_upload_output::Builder,
) -> Result<
	crate::output::prepare_identity_avatar_upload_output::Builder,
	aws_smithy_json::deserialize::Error,
> {
	let mut tokens_owned =
		aws_smithy_json::deserialize::json_token_iter(crate::json_deser::or_empty_doc(value))
			.peekable();
	let tokens = &mut tokens_owned;
	aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
	loop {
		match tokens.next().transpose()? {
			Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
			Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
				match key.to_unescaped()?.as_ref() {
					"presigned_request" => {
						builder = builder.set_presigned_request(
                            crate::json_deser::deser_structure_crate_model_upload_presigned_request(tokens)?
                        );
					}
					"upload_id" => {
						builder = builder.set_upload_id(
							aws_smithy_json::deserialize::token::expect_string_or_null(
								tokens.next(),
							)?
							.map(|s| s.to_unescaped().map(|u| u.into_owned()))
							.transpose()?,
						);
					}
					_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
				}
			}
			other => {
				return Err(aws_smithy_json::deserialize::Error::custom(format!(
					"expected object key or end object, found: {:?}",
					other
				)))
			}
		}
	}
	if tokens.next().is_some() {
		return Err(aws_smithy_json::deserialize::Error::custom(
			"found more JSON tokens after completing parsing",
		));
	}
	Ok(builder)
}

pub fn deser_operation_crate_operation_search_identities(
	value: &[u8],
	mut builder: crate::output::search_identities_output::Builder,
) -> Result<crate::output::search_identities_output::Builder, aws_smithy_json::deserialize::Error> {
	let mut tokens_owned =
		aws_smithy_json::deserialize::json_token_iter(crate::json_deser::or_empty_doc(value))
			.peekable();
	let tokens = &mut tokens_owned;
	aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
	loop {
		match tokens.next().transpose()? {
			Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
			Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
				match key.to_unescaped()?.as_ref() {
					"anchor" => {
						builder = builder.set_anchor(
							aws_smithy_json::deserialize::token::expect_string_or_null(
								tokens.next(),
							)?
							.map(|s| s.to_unescaped().map(|u| u.into_owned()))
							.transpose()?,
						);
					}
					"identities" => {
						builder = builder.set_identities(
							crate::json_deser::deser_list_rivet_identity_identity_handles(tokens)?,
						);
					}
					_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
				}
			}
			other => {
				return Err(aws_smithy_json::deserialize::Error::custom(format!(
					"expected object key or end object, found: {:?}",
					other
				)))
			}
		}
	}
	if tokens.next().is_some() {
		return Err(aws_smithy_json::deserialize::Error::custom(
			"found more JSON tokens after completing parsing",
		));
	}
	Ok(builder)
}

pub fn deser_operation_crate_operation_setup_identity(
	value: &[u8],
	mut builder: crate::output::setup_identity_output::Builder,
) -> Result<crate::output::setup_identity_output::Builder, aws_smithy_json::deserialize::Error> {
	let mut tokens_owned =
		aws_smithy_json::deserialize::json_token_iter(crate::json_deser::or_empty_doc(value))
			.peekable();
	let tokens = &mut tokens_owned;
	aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
	loop {
		match tokens.next().transpose()? {
			Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
			Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
				match key.to_unescaped()?.as_ref() {
					"game_id" => {
						builder = builder.set_game_id(
							aws_smithy_json::deserialize::token::expect_string_or_null(
								tokens.next(),
							)?
							.map(|s| s.to_unescaped().map(|u| u.into_owned()))
							.transpose()?,
						);
					}
					"identity" => {
						builder = builder.set_identity(
							crate::json_deser::deser_structure_crate_model_identity_profile(
								tokens,
							)?,
						);
					}
					"identity_token" => {
						builder = builder.set_identity_token(
							aws_smithy_json::deserialize::token::expect_string_or_null(
								tokens.next(),
							)?
							.map(|s| s.to_unescaped().map(|u| u.into_owned()))
							.transpose()?,
						);
					}
					"identity_token_expire_ts" => {
						builder = builder.set_identity_token_expire_ts(
							aws_smithy_json::deserialize::token::expect_timestamp_or_null(
								tokens.next(),
								aws_smithy_types::date_time::Format::DateTime,
							)?,
						);
					}
					_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
				}
			}
			other => {
				return Err(aws_smithy_json::deserialize::Error::custom(format!(
					"expected object key or end object, found: {:?}",
					other
				)))
			}
		}
	}
	if tokens.next().is_some() {
		return Err(aws_smithy_json::deserialize::Error::custom(
			"found more JSON tokens after completing parsing",
		));
	}
	Ok(builder)
}

pub fn deser_operation_crate_operation_validate_identity_profile(
	value: &[u8],
	mut builder: crate::output::validate_identity_profile_output::Builder,
) -> Result<
	crate::output::validate_identity_profile_output::Builder,
	aws_smithy_json::deserialize::Error,
> {
	let mut tokens_owned =
		aws_smithy_json::deserialize::json_token_iter(crate::json_deser::or_empty_doc(value))
			.peekable();
	let tokens = &mut tokens_owned;
	aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
	loop {
		match tokens.next().transpose()? {
			Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
			Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
				match key.to_unescaped()?.as_ref() {
					"errors" => {
						builder = builder.set_errors(
							crate::json_deser::deser_list_rivet_common_validation_errors(tokens)?,
						);
					}
					_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
				}
			}
			other => {
				return Err(aws_smithy_json::deserialize::Error::custom(format!(
					"expected object key or end object, found: {:?}",
					other
				)))
			}
		}
	}
	if tokens.next().is_some() {
		return Err(aws_smithy_json::deserialize::Error::custom(
			"found more JSON tokens after completing parsing",
		));
	}
	Ok(builder)
}

pub fn deser_operation_crate_operation_watch_events(
	value: &[u8],
	mut builder: crate::output::watch_events_output::Builder,
) -> Result<crate::output::watch_events_output::Builder, aws_smithy_json::deserialize::Error> {
	let mut tokens_owned =
		aws_smithy_json::deserialize::json_token_iter(crate::json_deser::or_empty_doc(value))
			.peekable();
	let tokens = &mut tokens_owned;
	aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
	loop {
		match tokens.next().transpose()? {
			Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
			Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
				match key.to_unescaped()?.as_ref() {
					"events" => {
						builder = builder.set_events(
							crate::json_deser::deser_list_rivet_api_identity_common_global_events(
								tokens,
							)?,
						);
					}
					"watch" => {
						builder = builder.set_watch(
							crate::json_deser::deser_structure_crate_model_watch_response(tokens)?,
						);
					}
					_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
				}
			}
			other => {
				return Err(aws_smithy_json::deserialize::Error::custom(format!(
					"expected object key or end object, found: {:?}",
					other
				)))
			}
		}
	}
	if tokens.next().is_some() {
		return Err(aws_smithy_json::deserialize::Error::custom(
			"found more JSON tokens after completing parsing",
		));
	}
	Ok(builder)
}

pub fn or_empty_doc(data: &[u8]) -> &[u8] {
	if data.is_empty() {
		b"{}"
	} else {
		data
	}
}

pub fn deser_structure_crate_model_identity_handle<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::IdentityHandle>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::IdentityHandle::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"identity_id" => {
								builder = builder.set_identity_id(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"display_name" => {
								builder = builder.set_display_name(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"account_number" => {
								builder = builder.set_account_number(
									aws_smithy_json::deserialize::token::expect_number_or_null(
										tokens.next(),
									)?
									.map(|v| v.to_i32()),
								);
							}
							"avatar_url" => {
								builder = builder.set_avatar_url(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"presence" => {
								builder = builder.set_presence(
                                    crate::json_deser::deser_structure_crate_model_identity_presence(tokens)?
                                );
							}
							"party" => {
								builder = builder.set_party(
									crate::json_deser::deser_structure_crate_model_party_handle(
										tokens,
									)?,
								);
							}
							"is_registered" => {
								builder = builder.set_is_registered(
									aws_smithy_json::deserialize::token::expect_bool_or_null(
										tokens.next(),
									)?,
								);
							}
							"external" => {
								builder = builder.set_external(
                                    crate::json_deser::deser_structure_crate_model_identity_external_links(tokens)?
                                );
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_game_handle<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::GameHandle>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::GameHandle::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"game_id" => {
								builder = builder.set_game_id(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"name_id" => {
								builder = builder.set_name_id(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"display_name" => {
								builder = builder.set_display_name(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"logo_url" => {
								builder = builder.set_logo_url(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"banner_url" => {
								builder = builder.set_banner_url(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_get_game_link_new_identity<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::GetGameLinkNewIdentity>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::GetGameLinkNewIdentity::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"identity_token" => {
								builder = builder.set_identity_token(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"identity_token_expire_ts" => {
								builder = builder.set_identity_token_expire_ts(
									aws_smithy_json::deserialize::token::expect_timestamp_or_null(
										tokens.next(),
										aws_smithy_types::date_time::Format::DateTime,
									)?,
								);
							}
							"identity" => {
								builder = builder.set_identity(
                                    crate::json_deser::deser_structure_crate_model_identity_profile(tokens)?
                                );
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_watch_response<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::WatchResponse>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::WatchResponse::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"index" => {
								builder = builder.set_index(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

#[allow(clippy::type_complexity, non_snake_case)]
pub fn deser_list_rivet_identity_identity_handles<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<std::vec::Vec<crate::model::IdentityHandle>>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartArray { .. }) => {
			let mut items = Vec::new();
			loop {
				match tokens.peek() {
					Some(Ok(aws_smithy_json::deserialize::Token::EndArray { .. })) => {
						tokens.next().transpose().unwrap();
						break;
					}
					_ => {
						let value =
							crate::json_deser::deser_structure_crate_model_identity_handle(tokens)?;
						if let Some(value) = value {
							items.push(value);
						}
					}
				}
			}
			Ok(Some(items))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start array or null",
		)),
	}
}

pub fn deser_structure_crate_model_identity_profile<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::IdentityProfile>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::IdentityProfile::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"identity_id" => {
								builder = builder.set_identity_id(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"display_name" => {
								builder = builder.set_display_name(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"account_number" => {
								builder = builder.set_account_number(
									aws_smithy_json::deserialize::token::expect_number_or_null(
										tokens.next(),
									)?
									.map(|v| v.to_i32()),
								);
							}
							"avatar_url" => {
								builder = builder.set_avatar_url(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"presence" => {
								builder = builder.set_presence(
                                    crate::json_deser::deser_structure_crate_model_identity_presence(tokens)?
                                );
							}
							"party" => {
								builder = builder.set_party(
									crate::json_deser::deser_structure_crate_model_party_summary(
										tokens,
									)?,
								);
							}
							"is_registered" => {
								builder = builder.set_is_registered(
									aws_smithy_json::deserialize::token::expect_bool_or_null(
										tokens.next(),
									)?,
								);
							}
							"external" => {
								builder = builder.set_external(
                                    crate::json_deser::deser_structure_crate_model_identity_external_links(tokens)?
                                );
							}
							"is_admin" => {
								builder = builder.set_is_admin(
									aws_smithy_json::deserialize::token::expect_bool_or_null(
										tokens.next(),
									)?,
								);
							}
							"is_game_linked" => {
								builder = builder.set_is_game_linked(
									aws_smithy_json::deserialize::token::expect_bool_or_null(
										tokens.next(),
									)?,
								);
							}
							"dev_state" => {
								builder = builder.set_dev_state(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| {
										s.to_unescaped().map(|u| {
											crate::model::IdentityDevState::from(u.as_ref())
										})
									})
									.transpose()?,
								);
							}
							"follower_count" => {
								builder = builder.set_follower_count(
									aws_smithy_json::deserialize::token::expect_number_or_null(
										tokens.next(),
									)?
									.map(|v| v.to_i32()),
								);
							}
							"following_count" => {
								builder = builder.set_following_count(
									aws_smithy_json::deserialize::token::expect_number_or_null(
										tokens.next(),
									)?
									.map(|v| v.to_i32()),
								);
							}
							"following" => {
								builder = builder.set_following(
									aws_smithy_json::deserialize::token::expect_bool_or_null(
										tokens.next(),
									)?,
								);
							}
							"is_following_me" => {
								builder = builder.set_is_following_me(
									aws_smithy_json::deserialize::token::expect_bool_or_null(
										tokens.next(),
									)?,
								);
							}
							"is_mutual_following" => {
								builder = builder.set_is_mutual_following(
									aws_smithy_json::deserialize::token::expect_bool_or_null(
										tokens.next(),
									)?,
								);
							}
							"join_ts" => {
								builder = builder.set_join_ts(
									aws_smithy_json::deserialize::token::expect_timestamp_or_null(
										tokens.next(),
										aws_smithy_types::date_time::Format::DateTime,
									)?,
								);
							}
							"bio" => {
								builder = builder.set_bio(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"linked_accounts" => {
								builder = builder.set_linked_accounts(
                                    crate::json_deser::deser_list_rivet_identity_identity_linked_accounts(tokens)?
                                );
							}
							"groups" => {
								builder = builder.set_groups(
									crate::json_deser::deser_list_rivet_identity_identity_groups(
										tokens,
									)?,
								);
							}
							"games" => {
								builder = builder.set_games(
									crate::json_deser::deser_list_rivet_game_game_stat_summaries(
										tokens,
									)?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

#[allow(clippy::type_complexity, non_snake_case)]
pub fn deser_list_rivet_identity_identity_summaries<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<std::vec::Vec<crate::model::IdentitySummary>>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartArray { .. }) => {
			let mut items = Vec::new();
			loop {
				match tokens.peek() {
					Some(Ok(aws_smithy_json::deserialize::Token::EndArray { .. })) => {
						tokens.next().transpose().unwrap();
						break;
					}
					_ => {
						let value =
							crate::json_deser::deser_structure_crate_model_identity_summary(
								tokens,
							)?;
						if let Some(value) = value {
							items.push(value);
						}
					}
				}
			}
			Ok(Some(items))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start array or null",
		)),
	}
}

#[allow(clippy::type_complexity, non_snake_case)]
pub fn deser_list_rivet_game_game_handles<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<std::vec::Vec<crate::model::GameHandle>>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartArray { .. }) => {
			let mut items = Vec::new();
			loop {
				match tokens.peek() {
					Some(Ok(aws_smithy_json::deserialize::Token::EndArray { .. })) => {
						tokens.next().transpose().unwrap();
						break;
					}
					_ => {
						let value =
							crate::json_deser::deser_structure_crate_model_game_handle(tokens)?;
						if let Some(value) = value {
							items.push(value);
						}
					}
				}
			}
			Ok(Some(items))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start array or null",
		)),
	}
}

#[allow(clippy::type_complexity, non_snake_case)]
pub fn deser_list_rivet_party_party_summaries<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<std::vec::Vec<crate::model::PartySummary>>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartArray { .. }) => {
			let mut items = Vec::new();
			loop {
				match tokens.peek() {
					Some(Ok(aws_smithy_json::deserialize::Token::EndArray { .. })) => {
						tokens.next().transpose().unwrap();
						break;
					}
					_ => {
						let value =
							crate::json_deser::deser_structure_crate_model_party_summary(tokens)?;
						if let Some(value) = value {
							items.push(value);
						}
					}
				}
			}
			Ok(Some(items))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start array or null",
		)),
	}
}

#[allow(clippy::type_complexity, non_snake_case)]
pub fn deser_list_rivet_group_group_summaries<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<std::vec::Vec<crate::model::GroupSummary>>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartArray { .. }) => {
			let mut items = Vec::new();
			loop {
				match tokens.peek() {
					Some(Ok(aws_smithy_json::deserialize::Token::EndArray { .. })) => {
						tokens.next().transpose().unwrap();
						break;
					}
					_ => {
						let value =
							crate::json_deser::deser_structure_crate_model_group_summary(tokens)?;
						if let Some(value) = value {
							items.push(value);
						}
					}
				}
			}
			Ok(Some(items))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start array or null",
		)),
	}
}

pub fn deser_structure_crate_model_upload_presigned_request<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::UploadPresignedRequest>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::UploadPresignedRequest::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"path" => {
								builder = builder.set_path(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"url" => {
								builder = builder.set_url(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

#[allow(clippy::type_complexity, non_snake_case)]
pub fn deser_list_rivet_common_validation_errors<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<std::vec::Vec<crate::model::ValidationError>>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartArray { .. }) => {
			let mut items = Vec::new();
			loop {
				match tokens.peek() {
					Some(Ok(aws_smithy_json::deserialize::Token::EndArray { .. })) => {
						tokens.next().transpose().unwrap();
						break;
					}
					_ => {
						let value =
							crate::json_deser::deser_structure_crate_model_validation_error(
								tokens,
							)?;
						if let Some(value) = value {
							items.push(value);
						}
					}
				}
			}
			Ok(Some(items))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start array or null",
		)),
	}
}

#[allow(clippy::type_complexity, non_snake_case)]
pub fn deser_list_rivet_api_identity_common_global_events<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<std::vec::Vec<crate::model::GlobalEvent>>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartArray { .. }) => {
			let mut items = Vec::new();
			loop {
				match tokens.peek() {
					Some(Ok(aws_smithy_json::deserialize::Token::EndArray { .. })) => {
						tokens.next().transpose().unwrap();
						break;
					}
					_ => {
						let value =
							crate::json_deser::deser_structure_crate_model_global_event(tokens)?;
						if let Some(value) = value {
							items.push(value);
						}
					}
				}
			}
			Ok(Some(items))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start array or null",
		)),
	}
}

pub fn deser_structure_crate_model_identity_presence<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::IdentityPresence>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::IdentityPresence::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"update_ts" => {
								builder = builder.set_update_ts(
									aws_smithy_json::deserialize::token::expect_timestamp_or_null(
										tokens.next(),
										aws_smithy_types::date_time::Format::DateTime,
									)?,
								);
							}
							"status" => {
								builder = builder.set_status(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| {
										s.to_unescaped()
											.map(|u| crate::model::IdentityStatus::from(u.as_ref()))
									})
									.transpose()?,
								);
							}
							"game_activity" => {
								builder = builder.set_game_activity(
                                    crate::json_deser::deser_structure_crate_model_identity_game_activity(tokens)?
                                );
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_party_handle<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::PartyHandle>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::PartyHandle::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"party_id" => {
								builder = builder.set_party_id(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"create_ts" => {
								builder = builder.set_create_ts(
									aws_smithy_json::deserialize::token::expect_timestamp_or_null(
										tokens.next(),
										aws_smithy_types::date_time::Format::DateTime,
									)?,
								);
							}
							"activity" => {
								builder = builder.set_activity(
									crate::json_deser::deser_union_crate_model_party_activity(
										tokens,
									)?,
								);
							}
							"external" => {
								builder = builder.set_external(
                                    crate::json_deser::deser_structure_crate_model_party_external_links(tokens)?
                                );
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_identity_external_links<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::IdentityExternalLinks>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::IdentityExternalLinks::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"profile" => {
								builder = builder.set_profile(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"settings" => {
								builder = builder.set_settings(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"chat" => {
								builder = builder.set_chat(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_party_summary<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::PartySummary>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::PartySummary::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"party_id" => {
								builder = builder.set_party_id(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"create_ts" => {
								builder = builder.set_create_ts(
									aws_smithy_json::deserialize::token::expect_timestamp_or_null(
										tokens.next(),
										aws_smithy_types::date_time::Format::DateTime,
									)?,
								);
							}
							"activity" => {
								builder = builder.set_activity(
									crate::json_deser::deser_union_crate_model_party_activity(
										tokens,
									)?,
								);
							}
							"external" => {
								builder = builder.set_external(
                                    crate::json_deser::deser_structure_crate_model_party_external_links(tokens)?
                                );
							}
							"publicity" => {
								builder = builder.set_publicity(
									crate::json_deser::deser_structure_crate_model_party_publicity(
										tokens,
									)?,
								);
							}
							"party_size" => {
								builder = builder.set_party_size(
									aws_smithy_json::deserialize::token::expect_number_or_null(
										tokens.next(),
									)?
									.map(|v| v.to_i32()),
								);
							}
							"members" => {
								builder = builder.set_members(
                                    crate::json_deser::deser_list_rivet_party_party_member_summaries(tokens)?
                                );
							}
							"thread_id" => {
								builder = builder.set_thread_id(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

#[allow(clippy::type_complexity, non_snake_case)]
pub fn deser_list_rivet_identity_identity_linked_accounts<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<
	Option<std::vec::Vec<crate::model::IdentityLinkedAccount>>,
	aws_smithy_json::deserialize::Error,
>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartArray { .. }) => {
			let mut items = Vec::new();
			loop {
				match tokens.peek() {
					Some(Ok(aws_smithy_json::deserialize::Token::EndArray { .. })) => {
						tokens.next().transpose().unwrap();
						break;
					}
					_ => {
						let value =
							crate::json_deser::deser_union_crate_model_identity_linked_account(
								tokens,
							)?;
						if let Some(value) = value {
							items.push(value);
						}
					}
				}
			}
			Ok(Some(items))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start array or null",
		)),
	}
}

#[allow(clippy::type_complexity, non_snake_case)]
pub fn deser_list_rivet_identity_identity_groups<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<std::vec::Vec<crate::model::IdentityGroup>>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartArray { .. }) => {
			let mut items = Vec::new();
			loop {
				match tokens.peek() {
					Some(Ok(aws_smithy_json::deserialize::Token::EndArray { .. })) => {
						tokens.next().transpose().unwrap();
						break;
					}
					_ => {
						let value =
							crate::json_deser::deser_structure_crate_model_identity_group(tokens)?;
						if let Some(value) = value {
							items.push(value);
						}
					}
				}
			}
			Ok(Some(items))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start array or null",
		)),
	}
}

#[allow(clippy::type_complexity, non_snake_case)]
pub fn deser_list_rivet_game_game_stat_summaries<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<std::vec::Vec<crate::model::GameStatSummary>>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartArray { .. }) => {
			let mut items = Vec::new();
			loop {
				match tokens.peek() {
					Some(Ok(aws_smithy_json::deserialize::Token::EndArray { .. })) => {
						tokens.next().transpose().unwrap();
						break;
					}
					_ => {
						let value =
							crate::json_deser::deser_structure_crate_model_game_stat_summary(
								tokens,
							)?;
						if let Some(value) = value {
							items.push(value);
						}
					}
				}
			}
			Ok(Some(items))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start array or null",
		)),
	}
}

pub fn deser_structure_crate_model_identity_summary<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::IdentitySummary>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::IdentitySummary::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"identity_id" => {
								builder = builder.set_identity_id(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"display_name" => {
								builder = builder.set_display_name(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"account_number" => {
								builder = builder.set_account_number(
									aws_smithy_json::deserialize::token::expect_number_or_null(
										tokens.next(),
									)?
									.map(|v| v.to_i32()),
								);
							}
							"avatar_url" => {
								builder = builder.set_avatar_url(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"presence" => {
								builder = builder.set_presence(
                                    crate::json_deser::deser_structure_crate_model_identity_presence(tokens)?
                                );
							}
							"party" => {
								builder = builder.set_party(
									crate::json_deser::deser_structure_crate_model_party_handle(
										tokens,
									)?,
								);
							}
							"is_registered" => {
								builder = builder.set_is_registered(
									aws_smithy_json::deserialize::token::expect_bool_or_null(
										tokens.next(),
									)?,
								);
							}
							"external" => {
								builder = builder.set_external(
                                    crate::json_deser::deser_structure_crate_model_identity_external_links(tokens)?
                                );
							}
							"following" => {
								builder = builder.set_following(
									aws_smithy_json::deserialize::token::expect_bool_or_null(
										tokens.next(),
									)?,
								);
							}
							"is_following_me" => {
								builder = builder.set_is_following_me(
									aws_smithy_json::deserialize::token::expect_bool_or_null(
										tokens.next(),
									)?,
								);
							}
							"is_mutual_following" => {
								builder = builder.set_is_mutual_following(
									aws_smithy_json::deserialize::token::expect_bool_or_null(
										tokens.next(),
									)?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_group_summary<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::GroupSummary>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::GroupSummary::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"group_id" => {
								builder = builder.set_group_id(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"display_name" => {
								builder = builder.set_display_name(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"avatar_url" => {
								builder = builder.set_avatar_url(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"external" => {
								builder = builder.set_external(
                                    crate::json_deser::deser_structure_crate_model_group_external_links(tokens)?
                                );
							}
							"is_developer" => {
								builder = builder.set_is_developer(
									aws_smithy_json::deserialize::token::expect_bool_or_null(
										tokens.next(),
									)?,
								);
							}
							"bio" => {
								builder = builder.set_bio(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"is_current_identity_member" => {
								builder = builder.set_is_current_identity_member(
									aws_smithy_json::deserialize::token::expect_bool_or_null(
										tokens.next(),
									)?,
								);
							}
							"publicity" => {
								builder = builder.set_publicity(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| {
										s.to_unescaped()
											.map(|u| crate::model::GroupPublicity::from(u.as_ref()))
									})
									.transpose()?,
								);
							}
							"member_count" => {
								builder = builder.set_member_count(
									aws_smithy_json::deserialize::token::expect_number_or_null(
										tokens.next(),
									)?
									.map(|v| v.to_i32()),
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_validation_error<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::ValidationError>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::ValidationError::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"path" => {
								builder = builder.set_path(
                                    crate::json_deser::deser_list_rivet_common_validation_error_path(tokens)?
                                );
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_global_event<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::GlobalEvent>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::GlobalEvent::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"ts" => {
								builder = builder.set_ts(
									aws_smithy_json::deserialize::token::expect_timestamp_or_null(
										tokens.next(),
										aws_smithy_types::date_time::Format::DateTime,
									)?,
								);
							}
							"kind" => {
								builder = builder.set_kind(
									crate::json_deser::deser_union_crate_model_global_event_kind(
										tokens,
									)?,
								);
							}
							"notification" => {
								builder = builder.set_notification(
                                    crate::json_deser::deser_structure_crate_model_global_event_notification(tokens)?
                                );
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_identity_game_activity<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::IdentityGameActivity>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::IdentityGameActivity::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"game" => {
								builder = builder.set_game(
									crate::json_deser::deser_structure_crate_model_game_handle(
										tokens,
									)?,
								);
							}
							"message" => {
								builder = builder.set_message(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"public_metadata" => {
								builder = builder.set_public_metadata(Some(
									aws_smithy_json::deserialize::token::expect_document(tokens)?,
								));
							}
							"mutual_metadata" => {
								builder = builder.set_mutual_metadata(Some(
									aws_smithy_json::deserialize::token::expect_document(tokens)?,
								));
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_union_crate_model_party_activity<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::PartyActivity>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	let mut variant = None;
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => return Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => loop {
			match tokens.next().transpose()? {
				Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
				Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
					if variant.is_some() {
						return Err(aws_smithy_json::deserialize::Error::custom(
							"encountered mixed variants in union",
						));
					}
					variant = match key.to_unescaped()?.as_ref() {
                            "idle" => {
                                Some(crate::model::PartyActivity::Idle(
                                    crate::json_deser::deser_structure_crate_model_party_activity_idle(tokens)?
                                    .ok_or_else(|| aws_smithy_json::deserialize::Error::custom("value for 'idle' cannot be null"))?
                                ))
                            }
                            "matchmaker_finding_lobby" => {
                                Some(crate::model::PartyActivity::MatchmakerFindingLobby(
                                    crate::json_deser::deser_structure_crate_model_party_activity_matchmaker_finding_lobby(tokens)?
                                    .ok_or_else(|| aws_smithy_json::deserialize::Error::custom("value for 'matchmaker_finding_lobby' cannot be null"))?
                                ))
                            }
                            "matchmaker_lobby" => {
                                Some(crate::model::PartyActivity::MatchmakerLobby(
                                    crate::json_deser::deser_structure_crate_model_party_activity_matchmaker_lobby(tokens)?
                                    .ok_or_else(|| aws_smithy_json::deserialize::Error::custom("value for 'matchmaker_lobby' cannot be null"))?
                                ))
                            }
                            _ => {
                                                                      aws_smithy_json::deserialize::token::skip_value(tokens)?;
                                                                      Some(crate::model::PartyActivity::Unknown)
                                                                    }
                        };
				}
				other => {
					return Err(aws_smithy_json::deserialize::Error::custom(format!(
						"expected object key or end object, found: {:?}",
						other
					)))
				}
			}
		},
		_ => {
			return Err(aws_smithy_json::deserialize::Error::custom(
				"expected start object or null",
			))
		}
	}
	Ok(variant)
}

pub fn deser_structure_crate_model_party_external_links<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::PartyExternalLinks>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::PartyExternalLinks::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"chat" => {
								builder = builder.set_chat(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_party_publicity<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::PartyPublicity>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::PartyPublicity::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"public" => {
								builder = builder.set_public(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| {
										s.to_unescaped().map(|u| {
											crate::model::PartyPublicityLevel::from(u.as_ref())
										})
									})
									.transpose()?,
								);
							}
							"mutual_followers" => {
								builder = builder.set_mutual_followers(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| {
										s.to_unescaped().map(|u| {
											crate::model::PartyPublicityLevel::from(u.as_ref())
										})
									})
									.transpose()?,
								);
							}
							"groups" => {
								builder = builder.set_groups(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| {
										s.to_unescaped().map(|u| {
											crate::model::PartyPublicityLevel::from(u.as_ref())
										})
									})
									.transpose()?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

#[allow(clippy::type_complexity, non_snake_case)]
pub fn deser_list_rivet_party_party_member_summaries<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<
	Option<std::vec::Vec<crate::model::PartyMemberSummary>>,
	aws_smithy_json::deserialize::Error,
>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartArray { .. }) => {
			let mut items = Vec::new();
			loop {
				match tokens.peek() {
					Some(Ok(aws_smithy_json::deserialize::Token::EndArray { .. })) => {
						tokens.next().transpose().unwrap();
						break;
					}
					_ => {
						let value =
							crate::json_deser::deser_structure_crate_model_party_member_summary(
								tokens,
							)?;
						if let Some(value) = value {
							items.push(value);
						}
					}
				}
			}
			Ok(Some(items))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start array or null",
		)),
	}
}

pub fn deser_union_crate_model_identity_linked_account<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::IdentityLinkedAccount>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	let mut variant = None;
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => return Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => loop {
			match tokens.next().transpose()? {
				Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
				Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
					if variant.is_some() {
						return Err(aws_smithy_json::deserialize::Error::custom(
							"encountered mixed variants in union",
						));
					}
					variant = match key.to_unescaped()?.as_ref() {
                            "email" => {
                                Some(crate::model::IdentityLinkedAccount::Email(
                                    crate::json_deser::deser_structure_crate_model_identity_email_linked_account(tokens)?
                                    .ok_or_else(|| aws_smithy_json::deserialize::Error::custom("value for 'email' cannot be null"))?
                                ))
                            }
                            _ => {
                                                                      aws_smithy_json::deserialize::token::skip_value(tokens)?;
                                                                      Some(crate::model::IdentityLinkedAccount::Unknown)
                                                                    }
                        };
				}
				other => {
					return Err(aws_smithy_json::deserialize::Error::custom(format!(
						"expected object key or end object, found: {:?}",
						other
					)))
				}
			}
		},
		_ => {
			return Err(aws_smithy_json::deserialize::Error::custom(
				"expected start object or null",
			))
		}
	}
	Ok(variant)
}

pub fn deser_structure_crate_model_identity_group<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::IdentityGroup>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::IdentityGroup::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"group" => {
								builder = builder.set_group(
									crate::json_deser::deser_structure_crate_model_group_handle(
										tokens,
									)?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_game_stat_summary<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::GameStatSummary>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::GameStatSummary::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"game" => {
								builder = builder.set_game(
									crate::json_deser::deser_structure_crate_model_game_handle(
										tokens,
									)?,
								);
							}
							"stats" => {
								builder = builder.set_stats(
									crate::json_deser::deser_list_rivet_game_game_stats(tokens)?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_group_external_links<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::GroupExternalLinks>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::GroupExternalLinks::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"profile" => {
								builder = builder.set_profile(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"chat" => {
								builder = builder.set_chat(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

#[allow(clippy::type_complexity, non_snake_case)]
pub fn deser_list_rivet_common_validation_error_path<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<std::vec::Vec<std::string::String>>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartArray { .. }) => {
			let mut items = Vec::new();
			loop {
				match tokens.peek() {
					Some(Ok(aws_smithy_json::deserialize::Token::EndArray { .. })) => {
						tokens.next().transpose().unwrap();
						break;
					}
					_ => {
						let value = aws_smithy_json::deserialize::token::expect_string_or_null(
							tokens.next(),
						)?
						.map(|s| s.to_unescaped().map(|u| u.into_owned()))
						.transpose()?;
						if let Some(value) = value {
							items.push(value);
						}
					}
				}
			}
			Ok(Some(items))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start array or null",
		)),
	}
}

pub fn deser_union_crate_model_global_event_kind<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::GlobalEventKind>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	let mut variant = None;
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => return Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => loop {
			match tokens.next().transpose()? {
				Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
				Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
					if variant.is_some() {
						return Err(aws_smithy_json::deserialize::Error::custom(
							"encountered mixed variants in union",
						));
					}
					variant = match key.to_unescaped()?.as_ref() {
                            "chat_message" => {
                                Some(crate::model::GlobalEventKind::ChatMessage(
                                    crate::json_deser::deser_structure_crate_model_global_event_chat_message(tokens)?
                                    .ok_or_else(|| aws_smithy_json::deserialize::Error::custom("value for 'chat_message' cannot be null"))?
                                ))
                            }
                            "chat_read" => {
                                Some(crate::model::GlobalEventKind::ChatRead(
                                    crate::json_deser::deser_structure_crate_model_global_event_chat_read(tokens)?
                                    .ok_or_else(|| aws_smithy_json::deserialize::Error::custom("value for 'chat_read' cannot be null"))?
                                ))
                            }
                            "party_update" => {
                                Some(crate::model::GlobalEventKind::PartyUpdate(
                                    crate::json_deser::deser_structure_crate_model_global_event_party_update(tokens)?
                                    .ok_or_else(|| aws_smithy_json::deserialize::Error::custom("value for 'party_update' cannot be null"))?
                                ))
                            }
                            "identity_update" => {
                                Some(crate::model::GlobalEventKind::IdentityUpdate(
                                    crate::json_deser::deser_structure_crate_model_global_event_identity_update(tokens)?
                                    .ok_or_else(|| aws_smithy_json::deserialize::Error::custom("value for 'identity_update' cannot be null"))?
                                ))
                            }
                            "matchmaker_lobby_join" => {
                                Some(crate::model::GlobalEventKind::MatchmakerLobbyJoin(
                                    crate::json_deser::deser_structure_crate_model_global_event_matchmaker_lobby_join(tokens)?
                                    .ok_or_else(|| aws_smithy_json::deserialize::Error::custom("value for 'matchmaker_lobby_join' cannot be null"))?
                                ))
                            }
                            "chat_thread_remove" => {
                                Some(crate::model::GlobalEventKind::ChatThreadRemove(
                                    crate::json_deser::deser_structure_crate_model_global_event_chat_thread_remove(tokens)?
                                    .ok_or_else(|| aws_smithy_json::deserialize::Error::custom("value for 'chat_thread_remove' cannot be null"))?
                                ))
                            }
                            _ => {
                                                                      aws_smithy_json::deserialize::token::skip_value(tokens)?;
                                                                      Some(crate::model::GlobalEventKind::Unknown)
                                                                    }
                        };
				}
				other => {
					return Err(aws_smithy_json::deserialize::Error::custom(format!(
						"expected object key or end object, found: {:?}",
						other
					)))
				}
			}
		},
		_ => {
			return Err(aws_smithy_json::deserialize::Error::custom(
				"expected start object or null",
			))
		}
	}
	Ok(variant)
}

pub fn deser_structure_crate_model_global_event_notification<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::GlobalEventNotification>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::GlobalEventNotification::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"title" => {
								builder = builder.set_title(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"description" => {
								builder = builder.set_description(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"thumbnail_url" => {
								builder = builder.set_thumbnail_url(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"url" => {
								builder = builder.set_url(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_party_activity_idle<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::PartyActivityIdle>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::PartyActivityIdle::builder();
			aws_smithy_json::deserialize::token::skip_to_end(tokens)?;
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_party_activity_matchmaker_finding_lobby<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<
	Option<crate::model::PartyActivityMatchmakerFindingLobby>,
	aws_smithy_json::deserialize::Error,
>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::PartyActivityMatchmakerFindingLobby::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"game" => {
								builder = builder.set_game(
									crate::json_deser::deser_structure_crate_model_game_handle(
										tokens,
									)?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_party_activity_matchmaker_lobby<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::PartyActivityMatchmakerLobby>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::PartyActivityMatchmakerLobby::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"lobby" => {
								builder = builder.set_lobby(
                                    crate::json_deser::deser_structure_crate_model_party_matchmaker_lobby(tokens)?
                                );
							}
							"game" => {
								builder = builder.set_game(
									crate::json_deser::deser_structure_crate_model_game_handle(
										tokens,
									)?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_party_member_summary<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::PartyMemberSummary>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::PartyMemberSummary::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"identity" => {
								builder = builder.set_identity(
									crate::json_deser::deser_structure_crate_model_identity_handle(
										tokens,
									)?,
								);
							}
							"is_leader" => {
								builder = builder.set_is_leader(
									aws_smithy_json::deserialize::token::expect_bool_or_null(
										tokens.next(),
									)?,
								);
							}
							"join_ts" => {
								builder = builder.set_join_ts(
									aws_smithy_json::deserialize::token::expect_timestamp_or_null(
										tokens.next(),
										aws_smithy_types::date_time::Format::DateTime,
									)?,
								);
							}
							"state" => {
								builder = builder.set_state(
									crate::json_deser::deser_union_crate_model_party_member_state(
										tokens,
									)?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_identity_email_linked_account<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::IdentityEmailLinkedAccount>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::IdentityEmailLinkedAccount::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"email" => {
								builder = builder.set_email(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_group_handle<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::GroupHandle>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::GroupHandle::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"group_id" => {
								builder = builder.set_group_id(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"display_name" => {
								builder = builder.set_display_name(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"avatar_url" => {
								builder = builder.set_avatar_url(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"external" => {
								builder = builder.set_external(
                                    crate::json_deser::deser_structure_crate_model_group_external_links(tokens)?
                                );
							}
							"is_developer" => {
								builder = builder.set_is_developer(
									aws_smithy_json::deserialize::token::expect_bool_or_null(
										tokens.next(),
									)?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

#[allow(clippy::type_complexity, non_snake_case)]
pub fn deser_list_rivet_game_game_stats<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<std::vec::Vec<crate::model::GameStat>>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartArray { .. }) => {
			let mut items = Vec::new();
			loop {
				match tokens.peek() {
					Some(Ok(aws_smithy_json::deserialize::Token::EndArray { .. })) => {
						tokens.next().transpose().unwrap();
						break;
					}
					_ => {
						let value =
							crate::json_deser::deser_structure_crate_model_game_stat(tokens)?;
						if let Some(value) = value {
							items.push(value);
						}
					}
				}
			}
			Ok(Some(items))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start array or null",
		)),
	}
}

pub fn deser_structure_crate_model_global_event_chat_message<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::GlobalEventChatMessage>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::GlobalEventChatMessage::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"thread" => {
								builder = builder.set_thread(
									crate::json_deser::deser_structure_crate_model_chat_thread(
										tokens,
									)?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_global_event_chat_read<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::GlobalEventChatRead>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::GlobalEventChatRead::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"thread_id" => {
								builder = builder.set_thread_id(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"read_ts" => {
								builder = builder.set_read_ts(
									aws_smithy_json::deserialize::token::expect_timestamp_or_null(
										tokens.next(),
										aws_smithy_types::date_time::Format::DateTime,
									)?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_global_event_party_update<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::GlobalEventPartyUpdate>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::GlobalEventPartyUpdate::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"party" => {
								builder = builder.set_party(
									crate::json_deser::deser_structure_crate_model_party_summary(
										tokens,
									)?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_global_event_identity_update<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::GlobalEventIdentityUpdate>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::GlobalEventIdentityUpdate::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"identity" => {
								builder = builder.set_identity(
                                    crate::json_deser::deser_structure_crate_model_identity_profile(tokens)?
                                );
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_global_event_matchmaker_lobby_join<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::GlobalEventMatchmakerLobbyJoin>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::GlobalEventMatchmakerLobbyJoin::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"lobby" => {
								builder = builder.set_lobby(
                                    crate::json_deser::deser_structure_crate_model_matchmaker_lobby_join_info(tokens)?
                                );
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_global_event_chat_thread_remove<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::GlobalEventChatThreadRemove>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::GlobalEventChatThreadRemove::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"thread_id" => {
								builder = builder.set_thread_id(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_party_matchmaker_lobby<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::PartyMatchmakerLobby>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::PartyMatchmakerLobby::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"lobby_id" => {
								builder = builder.set_lobby_id(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_union_crate_model_party_member_state<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::PartyMemberState>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	let mut variant = None;
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => return Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => loop {
			match tokens.next().transpose()? {
				Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
				Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
					if variant.is_some() {
						return Err(aws_smithy_json::deserialize::Error::custom(
							"encountered mixed variants in union",
						));
					}
					variant = match key.to_unescaped()?.as_ref() {
                            "idle" => {
                                Some(crate::model::PartyMemberState::Idle(
                                    crate::json_deser::deser_structure_crate_model_party_member_state_idle(tokens)?
                                    .ok_or_else(|| aws_smithy_json::deserialize::Error::custom("value for 'idle' cannot be null"))?
                                ))
                            }
                            "matchmaker_pending" => {
                                Some(crate::model::PartyMemberState::MatchmakerPending(
                                    crate::json_deser::deser_structure_crate_model_party_member_state_matchmaker_pending(tokens)?
                                    .ok_or_else(|| aws_smithy_json::deserialize::Error::custom("value for 'matchmaker_pending' cannot be null"))?
                                ))
                            }
                            "matchmaker_finding_lobby" => {
                                Some(crate::model::PartyMemberState::MatchmakerFindingLobby(
                                    crate::json_deser::deser_structure_crate_model_party_member_state_matchmaker_finding_lobby(tokens)?
                                    .ok_or_else(|| aws_smithy_json::deserialize::Error::custom("value for 'matchmaker_finding_lobby' cannot be null"))?
                                ))
                            }
                            "matchmaker_lobby" => {
                                Some(crate::model::PartyMemberState::MatchmakerLobby(
                                    crate::json_deser::deser_structure_crate_model_party_member_state_matchmaker_lobby(tokens)?
                                    .ok_or_else(|| aws_smithy_json::deserialize::Error::custom("value for 'matchmaker_lobby' cannot be null"))?
                                ))
                            }
                            _ => {
                                                                      aws_smithy_json::deserialize::token::skip_value(tokens)?;
                                                                      Some(crate::model::PartyMemberState::Unknown)
                                                                    }
                        };
				}
				other => {
					return Err(aws_smithy_json::deserialize::Error::custom(format!(
						"expected object key or end object, found: {:?}",
						other
					)))
				}
			}
		},
		_ => {
			return Err(aws_smithy_json::deserialize::Error::custom(
				"expected start object or null",
			))
		}
	}
	Ok(variant)
}

pub fn deser_structure_crate_model_game_stat<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::GameStat>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::GameStat::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"config" => {
								builder = builder.set_config(
                                    crate::json_deser::deser_structure_crate_model_game_stat_config(tokens)?
                                );
							}
							"overall_value" => {
								builder = builder.set_overall_value(
									aws_smithy_json::deserialize::token::expect_number_or_null(
										tokens.next(),
									)?
									.map(|v| v.to_f32()),
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_chat_thread<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::ChatThread>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::ChatThread::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"thread_id" => {
								builder = builder.set_thread_id(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"create_ts" => {
								builder = builder.set_create_ts(
									aws_smithy_json::deserialize::token::expect_timestamp_or_null(
										tokens.next(),
										aws_smithy_types::date_time::Format::DateTime,
									)?,
								);
							}
							"topic" => {
								builder = builder.set_topic(
									crate::json_deser::deser_union_crate_model_chat_topic(tokens)?,
								);
							}
							"tail_message" => {
								builder = builder.set_tail_message(
									crate::json_deser::deser_structure_crate_model_chat_message(
										tokens,
									)?,
								);
							}
							"last_read_ts" => {
								builder = builder.set_last_read_ts(
									aws_smithy_json::deserialize::token::expect_timestamp_or_null(
										tokens.next(),
										aws_smithy_types::date_time::Format::DateTime,
									)?,
								);
							}
							"unread_count" => {
								builder = builder.set_unread_count(
									aws_smithy_json::deserialize::token::expect_number_or_null(
										tokens.next(),
									)?
									.map(|v| v.to_i64()),
								);
							}
							"external" => {
								builder = builder.set_external(
                                    crate::json_deser::deser_structure_crate_model_chat_thread_external_links(tokens)?
                                );
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_matchmaker_lobby_join_info<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::MatchmakerLobbyJoinInfo>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::MatchmakerLobbyJoinInfo::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"lobby_id" => {
								builder = builder.set_lobby_id(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"region" => {
								builder = builder.set_region(
                                    crate::json_deser::deser_structure_crate_model_matchmaker_lobby_join_info_region(tokens)?
                                );
							}
							"ports" => {
								builder = builder.set_ports(
                                    crate::json_deser::deser_map_rivet_matchmaker_matchmaker_lobby_join_info_ports(tokens)?
                                );
							}
							"player" => {
								builder = builder.set_player(
                                    crate::json_deser::deser_structure_crate_model_matchmaker_lobby_join_info_player(tokens)?
                                );
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_party_member_state_idle<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::PartyMemberStateIdle>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::PartyMemberStateIdle::builder();
			aws_smithy_json::deserialize::token::skip_to_end(tokens)?;
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_party_member_state_matchmaker_pending<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<
	Option<crate::model::PartyMemberStateMatchmakerPending>,
	aws_smithy_json::deserialize::Error,
>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::PartyMemberStateMatchmakerPending::builder();
			aws_smithy_json::deserialize::token::skip_to_end(tokens)?;
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_party_member_state_matchmaker_finding_lobby<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<
	Option<crate::model::PartyMemberStateMatchmakerFindingLobby>,
	aws_smithy_json::deserialize::Error,
>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::PartyMemberStateMatchmakerFindingLobby::builder();
			aws_smithy_json::deserialize::token::skip_to_end(tokens)?;
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_party_member_state_matchmaker_lobby<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<
	Option<crate::model::PartyMemberStateMatchmakerLobby>,
	aws_smithy_json::deserialize::Error,
>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::PartyMemberStateMatchmakerLobby::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"player_id" => {
								builder = builder.set_player_id(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_game_stat_config<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::GameStatConfig>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::GameStatConfig::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"record_id" => {
								builder = builder.set_record_id(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"icon_id" => {
								builder = builder.set_icon_id(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"format" => {
								builder = builder.set_format(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| {
										s.to_unescaped().map(|u| {
											crate::model::GameStatFormatMethod::from(u.as_ref())
										})
									})
									.transpose()?,
								);
							}
							"aggregation" => {
								builder = builder.set_aggregation(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| {
										s.to_unescaped().map(|u| {
											crate::model::GameStatAggregationMethod::from(
												u.as_ref(),
											)
										})
									})
									.transpose()?,
								);
							}
							"sorting" => {
								builder = builder.set_sorting(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| {
										s.to_unescaped().map(|u| {
											crate::model::GameStatSortingMethod::from(u.as_ref())
										})
									})
									.transpose()?,
								);
							}
							"priority" => {
								builder = builder.set_priority(
									aws_smithy_json::deserialize::token::expect_number_or_null(
										tokens.next(),
									)?
									.map(|v| v.to_i32()),
								);
							}
							"display_name" => {
								builder = builder.set_display_name(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"postfix_singular" => {
								builder = builder.set_postfix_singular(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"postfix_plural" => {
								builder = builder.set_postfix_plural(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"prefix_singular" => {
								builder = builder.set_prefix_singular(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"prefix_plural" => {
								builder = builder.set_prefix_plural(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_union_crate_model_chat_topic<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::ChatTopic>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	let mut variant = None;
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => return Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => loop {
			match tokens.next().transpose()? {
				Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
				Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
					if variant.is_some() {
						return Err(aws_smithy_json::deserialize::Error::custom(
							"encountered mixed variants in union",
						));
					}
					variant = match key.to_unescaped()?.as_ref() {
						"group" => Some(crate::model::ChatTopic::Group(
							crate::json_deser::deser_structure_crate_model_chat_topic_group(
								tokens,
							)?
							.ok_or_else(|| {
								aws_smithy_json::deserialize::Error::custom(
									"value for 'group' cannot be null",
								)
							})?,
						)),
						"party" => Some(crate::model::ChatTopic::Party(
							crate::json_deser::deser_structure_crate_model_chat_topic_party(
								tokens,
							)?
							.ok_or_else(|| {
								aws_smithy_json::deserialize::Error::custom(
									"value for 'party' cannot be null",
								)
							})?,
						)),
						"direct" => Some(crate::model::ChatTopic::Direct(
							crate::json_deser::deser_structure_crate_model_chat_topic_direct(
								tokens,
							)?
							.ok_or_else(|| {
								aws_smithy_json::deserialize::Error::custom(
									"value for 'direct' cannot be null",
								)
							})?,
						)),
						_ => {
							aws_smithy_json::deserialize::token::skip_value(tokens)?;
							Some(crate::model::ChatTopic::Unknown)
						}
					};
				}
				other => {
					return Err(aws_smithy_json::deserialize::Error::custom(format!(
						"expected object key or end object, found: {:?}",
						other
					)))
				}
			}
		},
		_ => {
			return Err(aws_smithy_json::deserialize::Error::custom(
				"expected start object or null",
			))
		}
	}
	Ok(variant)
}

pub fn deser_structure_crate_model_chat_message<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::ChatMessage>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::ChatMessage::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"chat_message_id" => {
								builder = builder.set_chat_message_id(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"thread_id" => {
								builder = builder.set_thread_id(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"send_ts" => {
								builder = builder.set_send_ts(
									aws_smithy_json::deserialize::token::expect_timestamp_or_null(
										tokens.next(),
										aws_smithy_types::date_time::Format::DateTime,
									)?,
								);
							}
							"body" => {
								builder = builder.set_body(
									crate::json_deser::deser_union_crate_model_chat_message_body(
										tokens,
									)?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_chat_thread_external_links<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::ChatThreadExternalLinks>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::ChatThreadExternalLinks::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"chat" => {
								builder = builder.set_chat(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_matchmaker_lobby_join_info_region<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::MatchmakerLobbyJoinInfoRegion>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::MatchmakerLobbyJoinInfoRegion::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"region_id" => {
								builder = builder.set_region_id(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"display_name" => {
								builder = builder.set_display_name(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

#[allow(clippy::type_complexity, non_snake_case)]
pub fn deser_map_rivet_matchmaker_matchmaker_lobby_join_info_ports<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<
	Option<
		std::collections::HashMap<std::string::String, crate::model::MatchmakerLobbyJoinInfoPort>,
	>,
	aws_smithy_json::deserialize::Error,
>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			let mut map = std::collections::HashMap::new();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						let key = key.to_unescaped().map(|u| u.into_owned())?;
						let value =
                            crate::json_deser::deser_structure_crate_model_matchmaker_lobby_join_info_port(tokens)?
                        ;
						if let Some(value) = value {
							map.insert(key, value);
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(map))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_matchmaker_lobby_join_info_player<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::MatchmakerLobbyJoinInfoPlayer>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::MatchmakerLobbyJoinInfoPlayer::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"token" => {
								builder = builder.set_token(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_chat_topic_group<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::ChatTopicGroup>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::ChatTopicGroup::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"group" => {
								builder = builder.set_group(
									crate::json_deser::deser_structure_crate_model_group_handle(
										tokens,
									)?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_chat_topic_party<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::ChatTopicParty>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::ChatTopicParty::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"party" => {
								builder = builder.set_party(
									crate::json_deser::deser_structure_crate_model_party_handle(
										tokens,
									)?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_chat_topic_direct<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::ChatTopicDirect>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::ChatTopicDirect::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"identity_a" => {
								builder = builder.set_identity_a(
									crate::json_deser::deser_structure_crate_model_identity_handle(
										tokens,
									)?,
								);
							}
							"identity_b" => {
								builder = builder.set_identity_b(
									crate::json_deser::deser_structure_crate_model_identity_handle(
										tokens,
									)?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_union_crate_model_chat_message_body<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::ChatMessageBody>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	let mut variant = None;
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => return Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => loop {
			match tokens.next().transpose()? {
				Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
				Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
					if variant.is_some() {
						return Err(aws_smithy_json::deserialize::Error::custom(
							"encountered mixed variants in union",
						));
					}
					variant = match key.to_unescaped()?.as_ref() {
                            "text" => {
                                Some(crate::model::ChatMessageBody::Text(
                                    crate::json_deser::deser_structure_crate_model_chat_message_body_text(tokens)?
                                    .ok_or_else(|| aws_smithy_json::deserialize::Error::custom("value for 'text' cannot be null"))?
                                ))
                            }
                            "chat_create" => {
                                Some(crate::model::ChatMessageBody::ChatCreate(
                                    crate::json_deser::deser_structure_crate_model_chat_message_body_chat_create(tokens)?
                                    .ok_or_else(|| aws_smithy_json::deserialize::Error::custom("value for 'chat_create' cannot be null"))?
                                ))
                            }
                            "identity_follow" => {
                                Some(crate::model::ChatMessageBody::IdentityFollow(
                                    crate::json_deser::deser_structure_crate_model_chat_message_body_identity_follow(tokens)?
                                    .ok_or_else(|| aws_smithy_json::deserialize::Error::custom("value for 'identity_follow' cannot be null"))?
                                ))
                            }
                            "group_join" => {
                                Some(crate::model::ChatMessageBody::GroupJoin(
                                    crate::json_deser::deser_structure_crate_model_chat_message_body_group_join(tokens)?
                                    .ok_or_else(|| aws_smithy_json::deserialize::Error::custom("value for 'group_join' cannot be null"))?
                                ))
                            }
                            "group_leave" => {
                                Some(crate::model::ChatMessageBody::GroupLeave(
                                    crate::json_deser::deser_structure_crate_model_chat_message_body_group_leave(tokens)?
                                    .ok_or_else(|| aws_smithy_json::deserialize::Error::custom("value for 'group_leave' cannot be null"))?
                                ))
                            }
                            "party_invite" => {
                                Some(crate::model::ChatMessageBody::PartyInvite(
                                    crate::json_deser::deser_structure_crate_model_chat_message_body_party_invite(tokens)?
                                    .ok_or_else(|| aws_smithy_json::deserialize::Error::custom("value for 'party_invite' cannot be null"))?
                                ))
                            }
                            "party_join_request" => {
                                Some(crate::model::ChatMessageBody::PartyJoinRequest(
                                    crate::json_deser::deser_structure_crate_model_chat_message_body_party_join_request(tokens)?
                                    .ok_or_else(|| aws_smithy_json::deserialize::Error::custom("value for 'party_join_request' cannot be null"))?
                                ))
                            }
                            "party_join" => {
                                Some(crate::model::ChatMessageBody::PartyJoin(
                                    crate::json_deser::deser_structure_crate_model_chat_message_body_party_join(tokens)?
                                    .ok_or_else(|| aws_smithy_json::deserialize::Error::custom("value for 'party_join' cannot be null"))?
                                ))
                            }
                            "party_leave" => {
                                Some(crate::model::ChatMessageBody::PartyLeave(
                                    crate::json_deser::deser_structure_crate_model_chat_message_body_party_leave(tokens)?
                                    .ok_or_else(|| aws_smithy_json::deserialize::Error::custom("value for 'party_leave' cannot be null"))?
                                ))
                            }
                            "party_activity_change" => {
                                Some(crate::model::ChatMessageBody::PartyActivityChange(
                                    crate::json_deser::deser_structure_crate_model_chat_message_body_party_activity_change(tokens)?
                                    .ok_or_else(|| aws_smithy_json::deserialize::Error::custom("value for 'party_activity_change' cannot be null"))?
                                ))
                            }
                            _ => {
                                                                      aws_smithy_json::deserialize::token::skip_value(tokens)?;
                                                                      Some(crate::model::ChatMessageBody::Unknown)
                                                                    }
                        };
				}
				other => {
					return Err(aws_smithy_json::deserialize::Error::custom(format!(
						"expected object key or end object, found: {:?}",
						other
					)))
				}
			}
		},
		_ => {
			return Err(aws_smithy_json::deserialize::Error::custom(
				"expected start object or null",
			))
		}
	}
	Ok(variant)
}

pub fn deser_structure_crate_model_matchmaker_lobby_join_info_port<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::MatchmakerLobbyJoinInfoPort>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::MatchmakerLobbyJoinInfoPort::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"host" => {
								builder = builder.set_host(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"hostname" => {
								builder = builder.set_hostname(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"port" => {
								builder = builder.set_port(
									aws_smithy_json::deserialize::token::expect_number_or_null(
										tokens.next(),
									)?
									.map(|v| v.to_i32()),
								);
							}
							"port_range" => {
								builder = builder.set_port_range(
                                    crate::json_deser::deser_structure_crate_model_matchmaker_lobby_join_info_port_range(tokens)?
                                );
							}
							"is_tls" => {
								builder = builder.set_is_tls(
									aws_smithy_json::deserialize::token::expect_bool_or_null(
										tokens.next(),
									)?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_chat_message_body_text<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::ChatMessageBodyText>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::ChatMessageBodyText::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"sender" => {
								builder = builder.set_sender(
									crate::json_deser::deser_structure_crate_model_identity_handle(
										tokens,
									)?,
								);
							}
							"body" => {
								builder = builder.set_body(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_chat_message_body_chat_create<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::ChatMessageBodyChatCreate>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::ChatMessageBodyChatCreate::builder();
			aws_smithy_json::deserialize::token::skip_to_end(tokens)?;
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_chat_message_body_identity_follow<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::ChatMessageBodyIdentityFollow>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::ChatMessageBodyIdentityFollow::builder();
			aws_smithy_json::deserialize::token::skip_to_end(tokens)?;
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_chat_message_body_group_join<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::ChatMessageBodyGroupJoin>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::ChatMessageBodyGroupJoin::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"identity" => {
								builder = builder.set_identity(
									crate::json_deser::deser_structure_crate_model_identity_handle(
										tokens,
									)?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_chat_message_body_group_leave<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::ChatMessageBodyGroupLeave>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::ChatMessageBodyGroupLeave::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"identity" => {
								builder = builder.set_identity(
									crate::json_deser::deser_structure_crate_model_identity_handle(
										tokens,
									)?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_chat_message_body_party_invite<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::ChatMessageBodyPartyInvite>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::ChatMessageBodyPartyInvite::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"sender" => {
								builder = builder.set_sender(
									crate::json_deser::deser_structure_crate_model_identity_handle(
										tokens,
									)?,
								);
							}
							"party" => {
								builder = builder.set_party(
									crate::json_deser::deser_structure_crate_model_party_handle(
										tokens,
									)?,
								);
							}
							"invite_token" => {
								builder = builder.set_invite_token(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_chat_message_body_party_join_request<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<
	Option<crate::model::ChatMessageBodyPartyJoinRequest>,
	aws_smithy_json::deserialize::Error,
>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::ChatMessageBodyPartyJoinRequest::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"sender" => {
								builder = builder.set_sender(
									crate::json_deser::deser_structure_crate_model_identity_handle(
										tokens,
									)?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_chat_message_body_party_join<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::ChatMessageBodyPartyJoin>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::ChatMessageBodyPartyJoin::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"identity" => {
								builder = builder.set_identity(
									crate::json_deser::deser_structure_crate_model_identity_handle(
										tokens,
									)?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_chat_message_body_party_leave<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::ChatMessageBodyPartyLeave>, aws_smithy_json::deserialize::Error>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::ChatMessageBodyPartyLeave::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"identity" => {
								builder = builder.set_identity(
									crate::json_deser::deser_structure_crate_model_identity_handle(
										tokens,
									)?,
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_chat_message_body_party_activity_change<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<
	Option<crate::model::ChatMessageBodyPartyActivityChange>,
	aws_smithy_json::deserialize::Error,
>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::ChatMessageBodyPartyActivityChange::builder();
			aws_smithy_json::deserialize::token::skip_to_end(tokens)?;
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}

pub fn deser_structure_crate_model_matchmaker_lobby_join_info_port_range<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<
	Option<crate::model::MatchmakerLobbyJoinInfoPortRange>,
	aws_smithy_json::deserialize::Error,
>
where
	I: Iterator<
		Item = Result<aws_smithy_json::deserialize::Token<'a>, aws_smithy_json::deserialize::Error>,
	>,
{
	match tokens.next().transpose()? {
		Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
		Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
			#[allow(unused_mut)]
			let mut builder = crate::model::MatchmakerLobbyJoinInfoPortRange::builder();
			loop {
				match tokens.next().transpose()? {
					Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
					Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
						match key.to_unescaped()?.as_ref() {
							"min" => {
								builder = builder.set_min(
									aws_smithy_json::deserialize::token::expect_number_or_null(
										tokens.next(),
									)?
									.map(|v| v.to_i32()),
								);
							}
							"max" => {
								builder = builder.set_max(
									aws_smithy_json::deserialize::token::expect_number_or_null(
										tokens.next(),
									)?
									.map(|v| v.to_i32()),
								);
							}
							_ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
						}
					}
					other => {
						return Err(aws_smithy_json::deserialize::Error::custom(format!(
							"expected object key or end object, found: {:?}",
							other
						)))
					}
				}
			}
			Ok(Some(builder.build()))
		}
		_ => Err(aws_smithy_json::deserialize::Error::custom(
			"expected start object or null",
		)),
	}
}