rivet_party/

json_deser.rs

// 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_create_party(
	value: &[u8],
	mut builder: crate::output::create_party_output::Builder,
) -> Result<crate::output::create_party_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() {
					"invites" => {
						builder = builder.set_invites(
							crate::json_deser::deser_list_rivet_api_party_common_created_invites(
								tokens,
							)?,
						);
					}
					"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()?,
						);
					}
					_ => 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_create_party_invite(
	value: &[u8],
	mut builder: crate::output::create_party_invite_output::Builder,
) -> Result<crate::output::create_party_invite_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() {
					"invite" => {
						builder = builder.set_invite(
							crate::json_deser::deser_structure_crate_model_created_invite(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_party_from_invite(
	value: &[u8],
	mut builder: crate::output::get_party_from_invite_output::Builder,
) -> Result<crate::output::get_party_from_invite_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() {
					"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
				)))
			}
		}
	}
	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_party_profile(
	value: &[u8],
	mut builder: crate::output::get_party_profile_output::Builder,
) -> Result<crate::output::get_party_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() {
					"party" => {
						builder = builder.set_party(
							crate::json_deser::deser_structure_crate_model_party_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_party_self_profile(
	value: &[u8],
	mut builder: crate::output::get_party_self_profile_output::Builder,
) -> Result<
	crate::output::get_party_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() {
					"party" => {
						builder = builder.set_party(
							crate::json_deser::deser_structure_crate_model_party_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_party_self_summary(
	value: &[u8],
	mut builder: crate::output::get_party_self_summary_output::Builder,
) -> Result<
	crate::output::get_party_self_summary_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() {
					"party" => {
						builder = builder.set_party(
							crate::json_deser::deser_structure_crate_model_party_summary(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_party_summary(
	value: &[u8],
	mut builder: crate::output::get_party_summary_output::Builder,
) -> Result<crate::output::get_party_summary_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() {
					"party" => {
						builder = builder.set_party(
							crate::json_deser::deser_structure_crate_model_party_summary(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_join_party(
	value: &[u8],
	mut builder: crate::output::join_party_output::Builder,
) -> Result<crate::output::join_party_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() {
					"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()?,
						);
					}
					_ => 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
	}
}

#[allow(clippy::type_complexity, non_snake_case)]
pub fn deser_list_rivet_api_party_common_created_invites<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<std::vec::Vec<crate::model::CreatedInvite>>, 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_created_invite(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_created_invite<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::CreatedInvite>, 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::CreatedInvite::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_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",
		)),
	}
}

pub fn deser_structure_crate_model_party_profile<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::PartyProfile>, 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::PartyProfile::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()?,
								);
							}
							"invites" => {
								builder = builder.set_invites(
									crate::json_deser::deser_list_rivet_party_party_invites(
										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",
		)),
	}
}

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",
		)),
	}
}

#[allow(clippy::type_complexity, non_snake_case)]
pub fn deser_list_rivet_party_party_invites<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<std::vec::Vec<crate::model::PartyInvite>>, 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_invite(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_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_party_invite<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::PartyInvite>, 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::PartyInvite::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() {
							"invite_id" => {
								builder = builder.set_invite_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,
									)?,
								);
							}
							"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()?,
								);
							}
							"alias" => {
								builder = builder.set_alias(
                                    crate::json_deser::deser_structure_crate_model_party_invite_alias(tokens)?
                                );
							}
							"external" => {
								builder = builder.set_external(
                                    crate::json_deser::deser_structure_crate_model_party_invite_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_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_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_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_party_invite_alias<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::PartyInviteAlias>, 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::PartyInviteAlias::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() {
							"namespace_id" => {
								builder = builder.set_namespace_id(
									aws_smithy_json::deserialize::token::expect_string_or_null(
										tokens.next(),
									)?
									.map(|s| s.to_unescaped().map(|u| u.into_owned()))
									.transpose()?,
								);
							}
							"alias" => {
								builder = builder.set_alias(
									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_invite_external_links<'a, I>(
	tokens: &mut std::iter::Peekable<I>,
) -> Result<Option<crate::model::PartyInviteExternalLinks>, 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::PartyInviteExternalLinks::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() {
							"invite" => {
								builder = builder.set_invite(
									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_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_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_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",
		)),
	}
}