rivet_party/

model.rs

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
/// A party summary.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PartySummary {
	/// A universally unique identifier.
	pub party_id: std::option::Option<std::string::String>,
	/// RFC3339 timestamp.
	pub create_ts: std::option::Option<aws_smithy_types::DateTime>,
	/// A union representing the activity of a given party.
	pub activity: std::option::Option<crate::model::PartyActivity>,
	/// External links for a party.
	pub external: std::option::Option<crate::model::PartyExternalLinks>,
	#[allow(missing_docs)] // documentation missing in model
	pub publicity: std::option::Option<crate::model::PartyPublicity>,
	/// Unsigned 32 bit integer.
	pub party_size: std::option::Option<i32>,
	/// A list of party members.
	pub members: std::option::Option<std::vec::Vec<crate::model::PartyMemberSummary>>,
	/// A universally unique identifier.
	pub thread_id: std::option::Option<std::string::String>,
}
impl PartySummary {
	/// A universally unique identifier.
	pub fn party_id(&self) -> std::option::Option<&str> {
		self.party_id.as_deref()
	}
	/// RFC3339 timestamp.
	pub fn create_ts(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
		self.create_ts.as_ref()
	}
	/// A union representing the activity of a given party.
	pub fn activity(&self) -> std::option::Option<&crate::model::PartyActivity> {
		self.activity.as_ref()
	}
	/// External links for a party.
	pub fn external(&self) -> std::option::Option<&crate::model::PartyExternalLinks> {
		self.external.as_ref()
	}
	#[allow(missing_docs)] // documentation missing in model
	pub fn publicity(&self) -> std::option::Option<&crate::model::PartyPublicity> {
		self.publicity.as_ref()
	}
	/// Unsigned 32 bit integer.
	pub fn party_size(&self) -> std::option::Option<i32> {
		self.party_size
	}
	/// A list of party members.
	pub fn members(&self) -> std::option::Option<&[crate::model::PartyMemberSummary]> {
		self.members.as_deref()
	}
	/// A universally unique identifier.
	pub fn thread_id(&self) -> std::option::Option<&str> {
		self.thread_id.as_deref()
	}
}
impl std::fmt::Debug for PartySummary {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("PartySummary");
		formatter.field("party_id", &self.party_id);
		formatter.field("create_ts", &self.create_ts);
		formatter.field("activity", &self.activity);
		formatter.field("external", &self.external);
		formatter.field("publicity", &self.publicity);
		formatter.field("party_size", &self.party_size);
		formatter.field("members", &self.members);
		formatter.field("thread_id", &self.thread_id);
		formatter.finish()
	}
}
/// See [`PartySummary`](crate::model::PartySummary)
pub mod party_summary {
	/// A builder for [`PartySummary`](crate::model::PartySummary)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) party_id: std::option::Option<std::string::String>,
		pub(crate) create_ts: std::option::Option<aws_smithy_types::DateTime>,
		pub(crate) activity: std::option::Option<crate::model::PartyActivity>,
		pub(crate) external: std::option::Option<crate::model::PartyExternalLinks>,
		pub(crate) publicity: std::option::Option<crate::model::PartyPublicity>,
		pub(crate) party_size: std::option::Option<i32>,
		pub(crate) members: std::option::Option<std::vec::Vec<crate::model::PartyMemberSummary>>,
		pub(crate) thread_id: std::option::Option<std::string::String>,
	}
	impl Builder {
		/// A universally unique identifier.
		pub fn party_id(mut self, input: impl Into<std::string::String>) -> Self {
			self.party_id = Some(input.into());
			self
		}
		/// A universally unique identifier.
		pub fn set_party_id(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.party_id = input;
			self
		}
		/// RFC3339 timestamp.
		pub fn create_ts(mut self, input: aws_smithy_types::DateTime) -> Self {
			self.create_ts = Some(input);
			self
		}
		/// RFC3339 timestamp.
		pub fn set_create_ts(
			mut self,
			input: std::option::Option<aws_smithy_types::DateTime>,
		) -> Self {
			self.create_ts = input;
			self
		}
		/// A union representing the activity of a given party.
		pub fn activity(mut self, input: crate::model::PartyActivity) -> Self {
			self.activity = Some(input);
			self
		}
		/// A union representing the activity of a given party.
		pub fn set_activity(
			mut self,
			input: std::option::Option<crate::model::PartyActivity>,
		) -> Self {
			self.activity = input;
			self
		}
		/// External links for a party.
		pub fn external(mut self, input: crate::model::PartyExternalLinks) -> Self {
			self.external = Some(input);
			self
		}
		/// External links for a party.
		pub fn set_external(
			mut self,
			input: std::option::Option<crate::model::PartyExternalLinks>,
		) -> Self {
			self.external = input;
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn publicity(mut self, input: crate::model::PartyPublicity) -> Self {
			self.publicity = Some(input);
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn set_publicity(
			mut self,
			input: std::option::Option<crate::model::PartyPublicity>,
		) -> Self {
			self.publicity = input;
			self
		}
		/// Unsigned 32 bit integer.
		pub fn party_size(mut self, input: i32) -> Self {
			self.party_size = Some(input);
			self
		}
		/// Unsigned 32 bit integer.
		pub fn set_party_size(mut self, input: std::option::Option<i32>) -> Self {
			self.party_size = input;
			self
		}
		/// Appends an item to `members`.
		///
		/// To override the contents of this collection use [`set_members`](Self::set_members).
		///
		/// A list of party members.
		pub fn members(mut self, input: crate::model::PartyMemberSummary) -> Self {
			let mut v = self.members.unwrap_or_default();
			v.push(input);
			self.members = Some(v);
			self
		}
		/// A list of party members.
		pub fn set_members(
			mut self,
			input: std::option::Option<std::vec::Vec<crate::model::PartyMemberSummary>>,
		) -> Self {
			self.members = input;
			self
		}
		/// A universally unique identifier.
		pub fn thread_id(mut self, input: impl Into<std::string::String>) -> Self {
			self.thread_id = Some(input.into());
			self
		}
		/// A universally unique identifier.
		pub fn set_thread_id(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.thread_id = input;
			self
		}
		/// Consumes the builder and constructs a [`PartySummary`](crate::model::PartySummary)
		pub fn build(self) -> crate::model::PartySummary {
			crate::model::PartySummary {
				party_id: self.party_id,
				create_ts: self.create_ts,
				activity: self.activity,
				external: self.external,
				publicity: self.publicity,
				party_size: self.party_size,
				members: self.members,
				thread_id: self.thread_id,
			}
		}
	}
}
impl PartySummary {
	/// Creates a new builder-style object to manufacture [`PartySummary`](crate::model::PartySummary)
	pub fn builder() -> crate::model::party_summary::Builder {
		crate::model::party_summary::Builder::default()
	}
}

/// A party member summary.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PartyMemberSummary {
	/// An identity handle.
	pub identity: std::option::Option<crate::model::IdentityHandle>,
	/// Whether or not this party member is the leader of the given party.
	pub is_leader: std::option::Option<bool>,
	/// RFC3339 timestamp.
	pub join_ts: std::option::Option<aws_smithy_types::DateTime>,
	/// A union representing the current state of a party member.
	pub state: std::option::Option<crate::model::PartyMemberState>,
}
impl PartyMemberSummary {
	/// An identity handle.
	pub fn identity(&self) -> std::option::Option<&crate::model::IdentityHandle> {
		self.identity.as_ref()
	}
	/// Whether or not this party member is the leader of the given party.
	pub fn is_leader(&self) -> std::option::Option<bool> {
		self.is_leader
	}
	/// RFC3339 timestamp.
	pub fn join_ts(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
		self.join_ts.as_ref()
	}
	/// A union representing the current state of a party member.
	pub fn state(&self) -> std::option::Option<&crate::model::PartyMemberState> {
		self.state.as_ref()
	}
}
impl std::fmt::Debug for PartyMemberSummary {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("PartyMemberSummary");
		formatter.field("identity", &self.identity);
		formatter.field("is_leader", &self.is_leader);
		formatter.field("join_ts", &self.join_ts);
		formatter.field("state", &self.state);
		formatter.finish()
	}
}
/// See [`PartyMemberSummary`](crate::model::PartyMemberSummary)
pub mod party_member_summary {
	/// A builder for [`PartyMemberSummary`](crate::model::PartyMemberSummary)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) identity: std::option::Option<crate::model::IdentityHandle>,
		pub(crate) is_leader: std::option::Option<bool>,
		pub(crate) join_ts: std::option::Option<aws_smithy_types::DateTime>,
		pub(crate) state: std::option::Option<crate::model::PartyMemberState>,
	}
	impl Builder {
		/// An identity handle.
		pub fn identity(mut self, input: crate::model::IdentityHandle) -> Self {
			self.identity = Some(input);
			self
		}
		/// An identity handle.
		pub fn set_identity(
			mut self,
			input: std::option::Option<crate::model::IdentityHandle>,
		) -> Self {
			self.identity = input;
			self
		}
		/// Whether or not this party member is the leader of the given party.
		pub fn is_leader(mut self, input: bool) -> Self {
			self.is_leader = Some(input);
			self
		}
		/// Whether or not this party member is the leader of the given party.
		pub fn set_is_leader(mut self, input: std::option::Option<bool>) -> Self {
			self.is_leader = input;
			self
		}
		/// RFC3339 timestamp.
		pub fn join_ts(mut self, input: aws_smithy_types::DateTime) -> Self {
			self.join_ts = Some(input);
			self
		}
		/// RFC3339 timestamp.
		pub fn set_join_ts(
			mut self,
			input: std::option::Option<aws_smithy_types::DateTime>,
		) -> Self {
			self.join_ts = input;
			self
		}
		/// A union representing the current state of a party member.
		pub fn state(mut self, input: crate::model::PartyMemberState) -> Self {
			self.state = Some(input);
			self
		}
		/// A union representing the current state of a party member.
		pub fn set_state(
			mut self,
			input: std::option::Option<crate::model::PartyMemberState>,
		) -> Self {
			self.state = input;
			self
		}
		/// Consumes the builder and constructs a [`PartyMemberSummary`](crate::model::PartyMemberSummary)
		pub fn build(self) -> crate::model::PartyMemberSummary {
			crate::model::PartyMemberSummary {
				identity: self.identity,
				is_leader: self.is_leader,
				join_ts: self.join_ts,
				state: self.state,
			}
		}
	}
}
impl PartyMemberSummary {
	/// Creates a new builder-style object to manufacture [`PartyMemberSummary`](crate::model::PartyMemberSummary)
	pub fn builder() -> crate::model::party_member_summary::Builder {
		crate::model::party_member_summary::Builder::default()
	}
}

/// A union representing the current state of a party member.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub enum PartyMemberState {
	/// A party member state denoting that the member is idle.
	Idle(crate::model::PartyMemberStateIdle),
	/// A party member state denoting that the member is currently searching for a lobby.
	MatchmakerFindingLobby(crate::model::PartyMemberStateMatchmakerFindingLobby),
	/// A party member state denoting that the member is in a lobby.
	MatchmakerLobby(crate::model::PartyMemberStateMatchmakerLobby),
	/// A party member state denoting that the member is currently waiting to start matchmaking.
	MatchmakerPending(crate::model::PartyMemberStateMatchmakerPending),
	/// The `Unknown` variant represents cases where new union variant was received. Consider upgrading the SDK to the latest available version.
	/// An unknown enum variant
	///
	/// _Note: If you encounter this error, consider upgrading your SDK to the latest version._
	/// The `Unknown` variant represents cases where the server sent a value that wasn't recognized
	/// by the client. This can happen when the server adds new functionality, but the client has not been updated.
	/// To investigate this, consider turning on debug logging to print the raw HTTP response.
	#[non_exhaustive]
	Unknown,
}
impl PartyMemberState {
	/// Tries to convert the enum instance into [`Idle`](crate::model::PartyMemberState::Idle), extracting the inner [`PartyMemberStateIdle`](crate::model::PartyMemberStateIdle).
	/// Returns `Err(&Self)` if it can't be converted.
	pub fn as_idle(&self) -> std::result::Result<&crate::model::PartyMemberStateIdle, &Self> {
		if let PartyMemberState::Idle(val) = &self {
			Ok(val)
		} else {
			Err(self)
		}
	}
	/// Returns true if this is a [`Idle`](crate::model::PartyMemberState::Idle).
	pub fn is_idle(&self) -> bool {
		self.as_idle().is_ok()
	}
	/// Tries to convert the enum instance into [`MatchmakerFindingLobby`](crate::model::PartyMemberState::MatchmakerFindingLobby), extracting the inner [`PartyMemberStateMatchmakerFindingLobby`](crate::model::PartyMemberStateMatchmakerFindingLobby).
	/// Returns `Err(&Self)` if it can't be converted.
	pub fn as_matchmaker_finding_lobby(
		&self,
	) -> std::result::Result<&crate::model::PartyMemberStateMatchmakerFindingLobby, &Self> {
		if let PartyMemberState::MatchmakerFindingLobby(val) = &self {
			Ok(val)
		} else {
			Err(self)
		}
	}
	/// Returns true if this is a [`MatchmakerFindingLobby`](crate::model::PartyMemberState::MatchmakerFindingLobby).
	pub fn is_matchmaker_finding_lobby(&self) -> bool {
		self.as_matchmaker_finding_lobby().is_ok()
	}
	/// Tries to convert the enum instance into [`MatchmakerLobby`](crate::model::PartyMemberState::MatchmakerLobby), extracting the inner [`PartyMemberStateMatchmakerLobby`](crate::model::PartyMemberStateMatchmakerLobby).
	/// Returns `Err(&Self)` if it can't be converted.
	pub fn as_matchmaker_lobby(
		&self,
	) -> std::result::Result<&crate::model::PartyMemberStateMatchmakerLobby, &Self> {
		if let PartyMemberState::MatchmakerLobby(val) = &self {
			Ok(val)
		} else {
			Err(self)
		}
	}
	/// Returns true if this is a [`MatchmakerLobby`](crate::model::PartyMemberState::MatchmakerLobby).
	pub fn is_matchmaker_lobby(&self) -> bool {
		self.as_matchmaker_lobby().is_ok()
	}
	/// Tries to convert the enum instance into [`MatchmakerPending`](crate::model::PartyMemberState::MatchmakerPending), extracting the inner [`PartyMemberStateMatchmakerPending`](crate::model::PartyMemberStateMatchmakerPending).
	/// Returns `Err(&Self)` if it can't be converted.
	pub fn as_matchmaker_pending(
		&self,
	) -> std::result::Result<&crate::model::PartyMemberStateMatchmakerPending, &Self> {
		if let PartyMemberState::MatchmakerPending(val) = &self {
			Ok(val)
		} else {
			Err(self)
		}
	}
	/// Returns true if this is a [`MatchmakerPending`](crate::model::PartyMemberState::MatchmakerPending).
	pub fn is_matchmaker_pending(&self) -> bool {
		self.as_matchmaker_pending().is_ok()
	}
	/// Returns true if the enum instance is the `Unknown` variant.
	pub fn is_unknown(&self) -> bool {
		matches!(self, Self::Unknown)
	}
}

/// A party member state denoting that the member is in a lobby.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PartyMemberStateMatchmakerLobby {
	/// A universally unique identifier.
	pub player_id: std::option::Option<std::string::String>,
}
impl PartyMemberStateMatchmakerLobby {
	/// A universally unique identifier.
	pub fn player_id(&self) -> std::option::Option<&str> {
		self.player_id.as_deref()
	}
}
impl std::fmt::Debug for PartyMemberStateMatchmakerLobby {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("PartyMemberStateMatchmakerLobby");
		formatter.field("player_id", &self.player_id);
		formatter.finish()
	}
}
/// See [`PartyMemberStateMatchmakerLobby`](crate::model::PartyMemberStateMatchmakerLobby)
pub mod party_member_state_matchmaker_lobby {
	/// A builder for [`PartyMemberStateMatchmakerLobby`](crate::model::PartyMemberStateMatchmakerLobby)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) player_id: std::option::Option<std::string::String>,
	}
	impl Builder {
		/// A universally unique identifier.
		pub fn player_id(mut self, input: impl Into<std::string::String>) -> Self {
			self.player_id = Some(input.into());
			self
		}
		/// A universally unique identifier.
		pub fn set_player_id(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.player_id = input;
			self
		}
		/// Consumes the builder and constructs a [`PartyMemberStateMatchmakerLobby`](crate::model::PartyMemberStateMatchmakerLobby)
		pub fn build(self) -> crate::model::PartyMemberStateMatchmakerLobby {
			crate::model::PartyMemberStateMatchmakerLobby {
				player_id: self.player_id,
			}
		}
	}
}
impl PartyMemberStateMatchmakerLobby {
	/// Creates a new builder-style object to manufacture [`PartyMemberStateMatchmakerLobby`](crate::model::PartyMemberStateMatchmakerLobby)
	pub fn builder() -> crate::model::party_member_state_matchmaker_lobby::Builder {
		crate::model::party_member_state_matchmaker_lobby::Builder::default()
	}
}

/// A party member state denoting that the member is currently searching for a lobby.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PartyMemberStateMatchmakerFindingLobby {}
impl std::fmt::Debug for PartyMemberStateMatchmakerFindingLobby {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("PartyMemberStateMatchmakerFindingLobby");
		formatter.finish()
	}
}
/// See [`PartyMemberStateMatchmakerFindingLobby`](crate::model::PartyMemberStateMatchmakerFindingLobby)
pub mod party_member_state_matchmaker_finding_lobby {
	/// A builder for [`PartyMemberStateMatchmakerFindingLobby`](crate::model::PartyMemberStateMatchmakerFindingLobby)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {}
	impl Builder {
		/// Consumes the builder and constructs a [`PartyMemberStateMatchmakerFindingLobby`](crate::model::PartyMemberStateMatchmakerFindingLobby)
		pub fn build(self) -> crate::model::PartyMemberStateMatchmakerFindingLobby {
			crate::model::PartyMemberStateMatchmakerFindingLobby {}
		}
	}
}
impl PartyMemberStateMatchmakerFindingLobby {
	/// Creates a new builder-style object to manufacture [`PartyMemberStateMatchmakerFindingLobby`](crate::model::PartyMemberStateMatchmakerFindingLobby)
	pub fn builder() -> crate::model::party_member_state_matchmaker_finding_lobby::Builder {
		crate::model::party_member_state_matchmaker_finding_lobby::Builder::default()
	}
}

/// A party member state denoting that the member is currently waiting to start matchmaking.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PartyMemberStateMatchmakerPending {}
impl std::fmt::Debug for PartyMemberStateMatchmakerPending {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("PartyMemberStateMatchmakerPending");
		formatter.finish()
	}
}
/// See [`PartyMemberStateMatchmakerPending`](crate::model::PartyMemberStateMatchmakerPending)
pub mod party_member_state_matchmaker_pending {
	/// A builder for [`PartyMemberStateMatchmakerPending`](crate::model::PartyMemberStateMatchmakerPending)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {}
	impl Builder {
		/// Consumes the builder and constructs a [`PartyMemberStateMatchmakerPending`](crate::model::PartyMemberStateMatchmakerPending)
		pub fn build(self) -> crate::model::PartyMemberStateMatchmakerPending {
			crate::model::PartyMemberStateMatchmakerPending {}
		}
	}
}
impl PartyMemberStateMatchmakerPending {
	/// Creates a new builder-style object to manufacture [`PartyMemberStateMatchmakerPending`](crate::model::PartyMemberStateMatchmakerPending)
	pub fn builder() -> crate::model::party_member_state_matchmaker_pending::Builder {
		crate::model::party_member_state_matchmaker_pending::Builder::default()
	}
}

/// A party member state denoting that the member is idle.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PartyMemberStateIdle {}
impl std::fmt::Debug for PartyMemberStateIdle {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("PartyMemberStateIdle");
		formatter.finish()
	}
}
/// See [`PartyMemberStateIdle`](crate::model::PartyMemberStateIdle)
pub mod party_member_state_idle {
	/// A builder for [`PartyMemberStateIdle`](crate::model::PartyMemberStateIdle)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {}
	impl Builder {
		/// Consumes the builder and constructs a [`PartyMemberStateIdle`](crate::model::PartyMemberStateIdle)
		pub fn build(self) -> crate::model::PartyMemberStateIdle {
			crate::model::PartyMemberStateIdle {}
		}
	}
}
impl PartyMemberStateIdle {
	/// Creates a new builder-style object to manufacture [`PartyMemberStateIdle`](crate::model::PartyMemberStateIdle)
	pub fn builder() -> crate::model::party_member_state_idle::Builder {
		crate::model::party_member_state_idle::Builder::default()
	}
}

/// An identity handle.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct IdentityHandle {
	/// A universally unique identifier.
	pub identity_id: std::option::Option<std::string::String>,
	/// Represent a resource's readable display name.
	pub display_name: std::option::Option<std::string::String>,
	/// Identity profile account number (#1234). These are assigned in addition to an identity's display name in order to allow multiple identities to have the same display name while still providing a unique handle. These are unique to each display name; you can have multiple accounts with different display names and the same account number.
	pub account_number: std::option::Option<i32>,
	/// The URL of this identity's avatar image.
	pub avatar_url: std::option::Option<std::string::String>,
	/// Information about the identity's current status, party, and active game.
	pub presence: std::option::Option<crate::model::IdentityPresence>,
	/// A party handle.
	pub party: std::option::Option<crate::model::PartyHandle>,
	/// Whether or not this identity is registered with a linked account.
	pub is_registered: std::option::Option<bool>,
	/// External links for an identity.
	pub external: std::option::Option<crate::model::IdentityExternalLinks>,
}
impl IdentityHandle {
	/// A universally unique identifier.
	pub fn identity_id(&self) -> std::option::Option<&str> {
		self.identity_id.as_deref()
	}
	/// Represent a resource's readable display name.
	pub fn display_name(&self) -> std::option::Option<&str> {
		self.display_name.as_deref()
	}
	/// Identity profile account number (#1234). These are assigned in addition to an identity's display name in order to allow multiple identities to have the same display name while still providing a unique handle. These are unique to each display name; you can have multiple accounts with different display names and the same account number.
	pub fn account_number(&self) -> std::option::Option<i32> {
		self.account_number
	}
	/// The URL of this identity's avatar image.
	pub fn avatar_url(&self) -> std::option::Option<&str> {
		self.avatar_url.as_deref()
	}
	/// Information about the identity's current status, party, and active game.
	pub fn presence(&self) -> std::option::Option<&crate::model::IdentityPresence> {
		self.presence.as_ref()
	}
	/// A party handle.
	pub fn party(&self) -> std::option::Option<&crate::model::PartyHandle> {
		self.party.as_ref()
	}
	/// Whether or not this identity is registered with a linked account.
	pub fn is_registered(&self) -> std::option::Option<bool> {
		self.is_registered
	}
	/// External links for an identity.
	pub fn external(&self) -> std::option::Option<&crate::model::IdentityExternalLinks> {
		self.external.as_ref()
	}
}
impl std::fmt::Debug for IdentityHandle {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("IdentityHandle");
		formatter.field("identity_id", &self.identity_id);
		formatter.field("display_name", &self.display_name);
		formatter.field("account_number", &self.account_number);
		formatter.field("avatar_url", &self.avatar_url);
		formatter.field("presence", &self.presence);
		formatter.field("party", &self.party);
		formatter.field("is_registered", &self.is_registered);
		formatter.field("external", &self.external);
		formatter.finish()
	}
}
/// See [`IdentityHandle`](crate::model::IdentityHandle)
pub mod identity_handle {
	/// A builder for [`IdentityHandle`](crate::model::IdentityHandle)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) identity_id: std::option::Option<std::string::String>,
		pub(crate) display_name: std::option::Option<std::string::String>,
		pub(crate) account_number: std::option::Option<i32>,
		pub(crate) avatar_url: std::option::Option<std::string::String>,
		pub(crate) presence: std::option::Option<crate::model::IdentityPresence>,
		pub(crate) party: std::option::Option<crate::model::PartyHandle>,
		pub(crate) is_registered: std::option::Option<bool>,
		pub(crate) external: std::option::Option<crate::model::IdentityExternalLinks>,
	}
	impl Builder {
		/// A universally unique identifier.
		pub fn identity_id(mut self, input: impl Into<std::string::String>) -> Self {
			self.identity_id = Some(input.into());
			self
		}
		/// A universally unique identifier.
		pub fn set_identity_id(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.identity_id = input;
			self
		}
		/// Represent a resource's readable display name.
		pub fn display_name(mut self, input: impl Into<std::string::String>) -> Self {
			self.display_name = Some(input.into());
			self
		}
		/// Represent a resource's readable display name.
		pub fn set_display_name(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.display_name = input;
			self
		}
		/// Identity profile account number (#1234). These are assigned in addition to an identity's display name in order to allow multiple identities to have the same display name while still providing a unique handle. These are unique to each display name; you can have multiple accounts with different display names and the same account number.
		pub fn account_number(mut self, input: i32) -> Self {
			self.account_number = Some(input);
			self
		}
		/// Identity profile account number (#1234). These are assigned in addition to an identity's display name in order to allow multiple identities to have the same display name while still providing a unique handle. These are unique to each display name; you can have multiple accounts with different display names and the same account number.
		pub fn set_account_number(mut self, input: std::option::Option<i32>) -> Self {
			self.account_number = input;
			self
		}
		/// The URL of this identity's avatar image.
		pub fn avatar_url(mut self, input: impl Into<std::string::String>) -> Self {
			self.avatar_url = Some(input.into());
			self
		}
		/// The URL of this identity's avatar image.
		pub fn set_avatar_url(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.avatar_url = input;
			self
		}
		/// Information about the identity's current status, party, and active game.
		pub fn presence(mut self, input: crate::model::IdentityPresence) -> Self {
			self.presence = Some(input);
			self
		}
		/// Information about the identity's current status, party, and active game.
		pub fn set_presence(
			mut self,
			input: std::option::Option<crate::model::IdentityPresence>,
		) -> Self {
			self.presence = input;
			self
		}
		/// A party handle.
		pub fn party(mut self, input: crate::model::PartyHandle) -> Self {
			self.party = Some(input);
			self
		}
		/// A party handle.
		pub fn set_party(mut self, input: std::option::Option<crate::model::PartyHandle>) -> Self {
			self.party = input;
			self
		}
		/// Whether or not this identity is registered with a linked account.
		pub fn is_registered(mut self, input: bool) -> Self {
			self.is_registered = Some(input);
			self
		}
		/// Whether or not this identity is registered with a linked account.
		pub fn set_is_registered(mut self, input: std::option::Option<bool>) -> Self {
			self.is_registered = input;
			self
		}
		/// External links for an identity.
		pub fn external(mut self, input: crate::model::IdentityExternalLinks) -> Self {
			self.external = Some(input);
			self
		}
		/// External links for an identity.
		pub fn set_external(
			mut self,
			input: std::option::Option<crate::model::IdentityExternalLinks>,
		) -> Self {
			self.external = input;
			self
		}
		/// Consumes the builder and constructs a [`IdentityHandle`](crate::model::IdentityHandle)
		pub fn build(self) -> crate::model::IdentityHandle {
			crate::model::IdentityHandle {
				identity_id: self.identity_id,
				display_name: self.display_name,
				account_number: self.account_number,
				avatar_url: self.avatar_url,
				presence: self.presence,
				party: self.party,
				is_registered: self.is_registered,
				external: self.external,
			}
		}
	}
}
impl IdentityHandle {
	/// Creates a new builder-style object to manufacture [`IdentityHandle`](crate::model::IdentityHandle)
	pub fn builder() -> crate::model::identity_handle::Builder {
		crate::model::identity_handle::Builder::default()
	}
}

/// External links for an identity.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct IdentityExternalLinks {
	/// A link to this identity's profile page.
	pub profile: std::option::Option<std::string::String>,
	/// A link to the Rivet settings page.
	pub settings: std::option::Option<std::string::String>,
	/// A link to a chat page with the given identity.
	pub chat: std::option::Option<std::string::String>,
}
impl IdentityExternalLinks {
	/// A link to this identity's profile page.
	pub fn profile(&self) -> std::option::Option<&str> {
		self.profile.as_deref()
	}
	/// A link to the Rivet settings page.
	pub fn settings(&self) -> std::option::Option<&str> {
		self.settings.as_deref()
	}
	/// A link to a chat page with the given identity.
	pub fn chat(&self) -> std::option::Option<&str> {
		self.chat.as_deref()
	}
}
impl std::fmt::Debug for IdentityExternalLinks {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("IdentityExternalLinks");
		formatter.field("profile", &self.profile);
		formatter.field("settings", &self.settings);
		formatter.field("chat", &self.chat);
		formatter.finish()
	}
}
/// See [`IdentityExternalLinks`](crate::model::IdentityExternalLinks)
pub mod identity_external_links {
	/// A builder for [`IdentityExternalLinks`](crate::model::IdentityExternalLinks)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) profile: std::option::Option<std::string::String>,
		pub(crate) settings: std::option::Option<std::string::String>,
		pub(crate) chat: std::option::Option<std::string::String>,
	}
	impl Builder {
		/// A link to this identity's profile page.
		pub fn profile(mut self, input: impl Into<std::string::String>) -> Self {
			self.profile = Some(input.into());
			self
		}
		/// A link to this identity's profile page.
		pub fn set_profile(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.profile = input;
			self
		}
		/// A link to the Rivet settings page.
		pub fn settings(mut self, input: impl Into<std::string::String>) -> Self {
			self.settings = Some(input.into());
			self
		}
		/// A link to the Rivet settings page.
		pub fn set_settings(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.settings = input;
			self
		}
		/// A link to a chat page with the given identity.
		pub fn chat(mut self, input: impl Into<std::string::String>) -> Self {
			self.chat = Some(input.into());
			self
		}
		/// A link to a chat page with the given identity.
		pub fn set_chat(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.chat = input;
			self
		}
		/// Consumes the builder and constructs a [`IdentityExternalLinks`](crate::model::IdentityExternalLinks)
		pub fn build(self) -> crate::model::IdentityExternalLinks {
			crate::model::IdentityExternalLinks {
				profile: self.profile,
				settings: self.settings,
				chat: self.chat,
			}
		}
	}
}
impl IdentityExternalLinks {
	/// Creates a new builder-style object to manufacture [`IdentityExternalLinks`](crate::model::IdentityExternalLinks)
	pub fn builder() -> crate::model::identity_external_links::Builder {
		crate::model::identity_external_links::Builder::default()
	}
}

/// A party handle.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PartyHandle {
	/// A universally unique identifier.
	pub party_id: std::option::Option<std::string::String>,
	/// RFC3339 timestamp.
	pub create_ts: std::option::Option<aws_smithy_types::DateTime>,
	/// A union representing the activity of a given party.
	pub activity: std::option::Option<crate::model::PartyActivity>,
	/// External links for a party.
	pub external: std::option::Option<crate::model::PartyExternalLinks>,
}
impl PartyHandle {
	/// A universally unique identifier.
	pub fn party_id(&self) -> std::option::Option<&str> {
		self.party_id.as_deref()
	}
	/// RFC3339 timestamp.
	pub fn create_ts(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
		self.create_ts.as_ref()
	}
	/// A union representing the activity of a given party.
	pub fn activity(&self) -> std::option::Option<&crate::model::PartyActivity> {
		self.activity.as_ref()
	}
	/// External links for a party.
	pub fn external(&self) -> std::option::Option<&crate::model::PartyExternalLinks> {
		self.external.as_ref()
	}
}
impl std::fmt::Debug for PartyHandle {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("PartyHandle");
		formatter.field("party_id", &self.party_id);
		formatter.field("create_ts", &self.create_ts);
		formatter.field("activity", &self.activity);
		formatter.field("external", &self.external);
		formatter.finish()
	}
}
/// See [`PartyHandle`](crate::model::PartyHandle)
pub mod party_handle {
	/// A builder for [`PartyHandle`](crate::model::PartyHandle)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) party_id: std::option::Option<std::string::String>,
		pub(crate) create_ts: std::option::Option<aws_smithy_types::DateTime>,
		pub(crate) activity: std::option::Option<crate::model::PartyActivity>,
		pub(crate) external: std::option::Option<crate::model::PartyExternalLinks>,
	}
	impl Builder {
		/// A universally unique identifier.
		pub fn party_id(mut self, input: impl Into<std::string::String>) -> Self {
			self.party_id = Some(input.into());
			self
		}
		/// A universally unique identifier.
		pub fn set_party_id(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.party_id = input;
			self
		}
		/// RFC3339 timestamp.
		pub fn create_ts(mut self, input: aws_smithy_types::DateTime) -> Self {
			self.create_ts = Some(input);
			self
		}
		/// RFC3339 timestamp.
		pub fn set_create_ts(
			mut self,
			input: std::option::Option<aws_smithy_types::DateTime>,
		) -> Self {
			self.create_ts = input;
			self
		}
		/// A union representing the activity of a given party.
		pub fn activity(mut self, input: crate::model::PartyActivity) -> Self {
			self.activity = Some(input);
			self
		}
		/// A union representing the activity of a given party.
		pub fn set_activity(
			mut self,
			input: std::option::Option<crate::model::PartyActivity>,
		) -> Self {
			self.activity = input;
			self
		}
		/// External links for a party.
		pub fn external(mut self, input: crate::model::PartyExternalLinks) -> Self {
			self.external = Some(input);
			self
		}
		/// External links for a party.
		pub fn set_external(
			mut self,
			input: std::option::Option<crate::model::PartyExternalLinks>,
		) -> Self {
			self.external = input;
			self
		}
		/// Consumes the builder and constructs a [`PartyHandle`](crate::model::PartyHandle)
		pub fn build(self) -> crate::model::PartyHandle {
			crate::model::PartyHandle {
				party_id: self.party_id,
				create_ts: self.create_ts,
				activity: self.activity,
				external: self.external,
			}
		}
	}
}
impl PartyHandle {
	/// Creates a new builder-style object to manufacture [`PartyHandle`](crate::model::PartyHandle)
	pub fn builder() -> crate::model::party_handle::Builder {
		crate::model::party_handle::Builder::default()
	}
}

/// External links for a party.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PartyExternalLinks {
	/// A link to the given party's chat thread.
	pub chat: std::option::Option<std::string::String>,
}
impl PartyExternalLinks {
	/// A link to the given party's chat thread.
	pub fn chat(&self) -> std::option::Option<&str> {
		self.chat.as_deref()
	}
}
impl std::fmt::Debug for PartyExternalLinks {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("PartyExternalLinks");
		formatter.field("chat", &self.chat);
		formatter.finish()
	}
}
/// See [`PartyExternalLinks`](crate::model::PartyExternalLinks)
pub mod party_external_links {
	/// A builder for [`PartyExternalLinks`](crate::model::PartyExternalLinks)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) chat: std::option::Option<std::string::String>,
	}
	impl Builder {
		/// A link to the given party's chat thread.
		pub fn chat(mut self, input: impl Into<std::string::String>) -> Self {
			self.chat = Some(input.into());
			self
		}
		/// A link to the given party's chat thread.
		pub fn set_chat(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.chat = input;
			self
		}
		/// Consumes the builder and constructs a [`PartyExternalLinks`](crate::model::PartyExternalLinks)
		pub fn build(self) -> crate::model::PartyExternalLinks {
			crate::model::PartyExternalLinks { chat: self.chat }
		}
	}
}
impl PartyExternalLinks {
	/// Creates a new builder-style object to manufacture [`PartyExternalLinks`](crate::model::PartyExternalLinks)
	pub fn builder() -> crate::model::party_external_links::Builder {
		crate::model::party_external_links::Builder::default()
	}
}

/// A union representing the activity of a given party.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub enum PartyActivity {
	/// A party activity denoting that the party is idle.
	Idle(crate::model::PartyActivityIdle),
	/// A party activity denoting that the party is currently searching for a lobby.
	MatchmakerFindingLobby(crate::model::PartyActivityMatchmakerFindingLobby),
	/// A party activity denoting that the party is currently in a lobby.
	MatchmakerLobby(crate::model::PartyActivityMatchmakerLobby),
	/// The `Unknown` variant represents cases where new union variant was received. Consider upgrading the SDK to the latest available version.
	/// An unknown enum variant
	///
	/// _Note: If you encounter this error, consider upgrading your SDK to the latest version._
	/// The `Unknown` variant represents cases where the server sent a value that wasn't recognized
	/// by the client. This can happen when the server adds new functionality, but the client has not been updated.
	/// To investigate this, consider turning on debug logging to print the raw HTTP response.
	#[non_exhaustive]
	Unknown,
}
impl PartyActivity {
	/// Tries to convert the enum instance into [`Idle`](crate::model::PartyActivity::Idle), extracting the inner [`PartyActivityIdle`](crate::model::PartyActivityIdle).
	/// Returns `Err(&Self)` if it can't be converted.
	pub fn as_idle(&self) -> std::result::Result<&crate::model::PartyActivityIdle, &Self> {
		if let PartyActivity::Idle(val) = &self {
			Ok(val)
		} else {
			Err(self)
		}
	}
	/// Returns true if this is a [`Idle`](crate::model::PartyActivity::Idle).
	pub fn is_idle(&self) -> bool {
		self.as_idle().is_ok()
	}
	/// Tries to convert the enum instance into [`MatchmakerFindingLobby`](crate::model::PartyActivity::MatchmakerFindingLobby), extracting the inner [`PartyActivityMatchmakerFindingLobby`](crate::model::PartyActivityMatchmakerFindingLobby).
	/// Returns `Err(&Self)` if it can't be converted.
	pub fn as_matchmaker_finding_lobby(
		&self,
	) -> std::result::Result<&crate::model::PartyActivityMatchmakerFindingLobby, &Self> {
		if let PartyActivity::MatchmakerFindingLobby(val) = &self {
			Ok(val)
		} else {
			Err(self)
		}
	}
	/// Returns true if this is a [`MatchmakerFindingLobby`](crate::model::PartyActivity::MatchmakerFindingLobby).
	pub fn is_matchmaker_finding_lobby(&self) -> bool {
		self.as_matchmaker_finding_lobby().is_ok()
	}
	/// Tries to convert the enum instance into [`MatchmakerLobby`](crate::model::PartyActivity::MatchmakerLobby), extracting the inner [`PartyActivityMatchmakerLobby`](crate::model::PartyActivityMatchmakerLobby).
	/// Returns `Err(&Self)` if it can't be converted.
	pub fn as_matchmaker_lobby(
		&self,
	) -> std::result::Result<&crate::model::PartyActivityMatchmakerLobby, &Self> {
		if let PartyActivity::MatchmakerLobby(val) = &self {
			Ok(val)
		} else {
			Err(self)
		}
	}
	/// Returns true if this is a [`MatchmakerLobby`](crate::model::PartyActivity::MatchmakerLobby).
	pub fn is_matchmaker_lobby(&self) -> bool {
		self.as_matchmaker_lobby().is_ok()
	}
	/// Returns true if the enum instance is the `Unknown` variant.
	pub fn is_unknown(&self) -> bool {
		matches!(self, Self::Unknown)
	}
}

/// A party activity denoting that the party is currently in a lobby.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PartyActivityMatchmakerLobby {
	/// A party lobby.
	pub lobby: std::option::Option<crate::model::PartyMatchmakerLobby>,
	/// A game handle.
	pub game: std::option::Option<crate::model::GameHandle>,
}
impl PartyActivityMatchmakerLobby {
	/// A party lobby.
	pub fn lobby(&self) -> std::option::Option<&crate::model::PartyMatchmakerLobby> {
		self.lobby.as_ref()
	}
	/// A game handle.
	pub fn game(&self) -> std::option::Option<&crate::model::GameHandle> {
		self.game.as_ref()
	}
}
impl std::fmt::Debug for PartyActivityMatchmakerLobby {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("PartyActivityMatchmakerLobby");
		formatter.field("lobby", &self.lobby);
		formatter.field("game", &self.game);
		formatter.finish()
	}
}
/// See [`PartyActivityMatchmakerLobby`](crate::model::PartyActivityMatchmakerLobby)
pub mod party_activity_matchmaker_lobby {
	/// A builder for [`PartyActivityMatchmakerLobby`](crate::model::PartyActivityMatchmakerLobby)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) lobby: std::option::Option<crate::model::PartyMatchmakerLobby>,
		pub(crate) game: std::option::Option<crate::model::GameHandle>,
	}
	impl Builder {
		/// A party lobby.
		pub fn lobby(mut self, input: crate::model::PartyMatchmakerLobby) -> Self {
			self.lobby = Some(input);
			self
		}
		/// A party lobby.
		pub fn set_lobby(
			mut self,
			input: std::option::Option<crate::model::PartyMatchmakerLobby>,
		) -> Self {
			self.lobby = input;
			self
		}
		/// A game handle.
		pub fn game(mut self, input: crate::model::GameHandle) -> Self {
			self.game = Some(input);
			self
		}
		/// A game handle.
		pub fn set_game(mut self, input: std::option::Option<crate::model::GameHandle>) -> Self {
			self.game = input;
			self
		}
		/// Consumes the builder and constructs a [`PartyActivityMatchmakerLobby`](crate::model::PartyActivityMatchmakerLobby)
		pub fn build(self) -> crate::model::PartyActivityMatchmakerLobby {
			crate::model::PartyActivityMatchmakerLobby {
				lobby: self.lobby,
				game: self.game,
			}
		}
	}
}
impl PartyActivityMatchmakerLobby {
	/// Creates a new builder-style object to manufacture [`PartyActivityMatchmakerLobby`](crate::model::PartyActivityMatchmakerLobby)
	pub fn builder() -> crate::model::party_activity_matchmaker_lobby::Builder {
		crate::model::party_activity_matchmaker_lobby::Builder::default()
	}
}

/// A game handle.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GameHandle {
	/// A universally unique identifier.
	pub game_id: std::option::Option<std::string::String>,
	/// A human readable short identifier used to references resources. Different than a `rivet.common#Uuid` because this is intended to be human readable. Different than `rivet.common#DisplayName` because this should not include special characters and be short.
	pub name_id: std::option::Option<std::string::String>,
	/// Represent a resource's readable display name.
	pub display_name: std::option::Option<std::string::String>,
	/// The URL of this game's logo image.
	pub logo_url: std::option::Option<std::string::String>,
	/// The URL of this game's banner image.
	pub banner_url: std::option::Option<std::string::String>,
}
impl GameHandle {
	/// A universally unique identifier.
	pub fn game_id(&self) -> std::option::Option<&str> {
		self.game_id.as_deref()
	}
	/// A human readable short identifier used to references resources. Different than a `rivet.common#Uuid` because this is intended to be human readable. Different than `rivet.common#DisplayName` because this should not include special characters and be short.
	pub fn name_id(&self) -> std::option::Option<&str> {
		self.name_id.as_deref()
	}
	/// Represent a resource's readable display name.
	pub fn display_name(&self) -> std::option::Option<&str> {
		self.display_name.as_deref()
	}
	/// The URL of this game's logo image.
	pub fn logo_url(&self) -> std::option::Option<&str> {
		self.logo_url.as_deref()
	}
	/// The URL of this game's banner image.
	pub fn banner_url(&self) -> std::option::Option<&str> {
		self.banner_url.as_deref()
	}
}
impl std::fmt::Debug for GameHandle {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("GameHandle");
		formatter.field("game_id", &self.game_id);
		formatter.field("name_id", &self.name_id);
		formatter.field("display_name", &self.display_name);
		formatter.field("logo_url", &self.logo_url);
		formatter.field("banner_url", &self.banner_url);
		formatter.finish()
	}
}
/// See [`GameHandle`](crate::model::GameHandle)
pub mod game_handle {
	/// A builder for [`GameHandle`](crate::model::GameHandle)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) game_id: std::option::Option<std::string::String>,
		pub(crate) name_id: std::option::Option<std::string::String>,
		pub(crate) display_name: std::option::Option<std::string::String>,
		pub(crate) logo_url: std::option::Option<std::string::String>,
		pub(crate) banner_url: std::option::Option<std::string::String>,
	}
	impl Builder {
		/// A universally unique identifier.
		pub fn game_id(mut self, input: impl Into<std::string::String>) -> Self {
			self.game_id = Some(input.into());
			self
		}
		/// A universally unique identifier.
		pub fn set_game_id(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.game_id = input;
			self
		}
		/// A human readable short identifier used to references resources. Different than a `rivet.common#Uuid` because this is intended to be human readable. Different than `rivet.common#DisplayName` because this should not include special characters and be short.
		pub fn name_id(mut self, input: impl Into<std::string::String>) -> Self {
			self.name_id = Some(input.into());
			self
		}
		/// A human readable short identifier used to references resources. Different than a `rivet.common#Uuid` because this is intended to be human readable. Different than `rivet.common#DisplayName` because this should not include special characters and be short.
		pub fn set_name_id(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.name_id = input;
			self
		}
		/// Represent a resource's readable display name.
		pub fn display_name(mut self, input: impl Into<std::string::String>) -> Self {
			self.display_name = Some(input.into());
			self
		}
		/// Represent a resource's readable display name.
		pub fn set_display_name(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.display_name = input;
			self
		}
		/// The URL of this game's logo image.
		pub fn logo_url(mut self, input: impl Into<std::string::String>) -> Self {
			self.logo_url = Some(input.into());
			self
		}
		/// The URL of this game's logo image.
		pub fn set_logo_url(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.logo_url = input;
			self
		}
		/// The URL of this game's banner image.
		pub fn banner_url(mut self, input: impl Into<std::string::String>) -> Self {
			self.banner_url = Some(input.into());
			self
		}
		/// The URL of this game's banner image.
		pub fn set_banner_url(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.banner_url = input;
			self
		}
		/// Consumes the builder and constructs a [`GameHandle`](crate::model::GameHandle)
		pub fn build(self) -> crate::model::GameHandle {
			crate::model::GameHandle {
				game_id: self.game_id,
				name_id: self.name_id,
				display_name: self.display_name,
				logo_url: self.logo_url,
				banner_url: self.banner_url,
			}
		}
	}
}
impl GameHandle {
	/// Creates a new builder-style object to manufacture [`GameHandle`](crate::model::GameHandle)
	pub fn builder() -> crate::model::game_handle::Builder {
		crate::model::game_handle::Builder::default()
	}
}

/// A party lobby.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PartyMatchmakerLobby {
	/// A universally unique identifier.
	pub lobby_id: std::option::Option<std::string::String>,
}
impl PartyMatchmakerLobby {
	/// A universally unique identifier.
	pub fn lobby_id(&self) -> std::option::Option<&str> {
		self.lobby_id.as_deref()
	}
}
impl std::fmt::Debug for PartyMatchmakerLobby {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("PartyMatchmakerLobby");
		formatter.field("lobby_id", &self.lobby_id);
		formatter.finish()
	}
}
/// See [`PartyMatchmakerLobby`](crate::model::PartyMatchmakerLobby)
pub mod party_matchmaker_lobby {
	/// A builder for [`PartyMatchmakerLobby`](crate::model::PartyMatchmakerLobby)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) lobby_id: std::option::Option<std::string::String>,
	}
	impl Builder {
		/// A universally unique identifier.
		pub fn lobby_id(mut self, input: impl Into<std::string::String>) -> Self {
			self.lobby_id = Some(input.into());
			self
		}
		/// A universally unique identifier.
		pub fn set_lobby_id(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.lobby_id = input;
			self
		}
		/// Consumes the builder and constructs a [`PartyMatchmakerLobby`](crate::model::PartyMatchmakerLobby)
		pub fn build(self) -> crate::model::PartyMatchmakerLobby {
			crate::model::PartyMatchmakerLobby {
				lobby_id: self.lobby_id,
			}
		}
	}
}
impl PartyMatchmakerLobby {
	/// Creates a new builder-style object to manufacture [`PartyMatchmakerLobby`](crate::model::PartyMatchmakerLobby)
	pub fn builder() -> crate::model::party_matchmaker_lobby::Builder {
		crate::model::party_matchmaker_lobby::Builder::default()
	}
}

/// A party activity denoting that the party is currently searching for a lobby.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PartyActivityMatchmakerFindingLobby {
	/// A game handle.
	pub game: std::option::Option<crate::model::GameHandle>,
}
impl PartyActivityMatchmakerFindingLobby {
	/// A game handle.
	pub fn game(&self) -> std::option::Option<&crate::model::GameHandle> {
		self.game.as_ref()
	}
}
impl std::fmt::Debug for PartyActivityMatchmakerFindingLobby {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("PartyActivityMatchmakerFindingLobby");
		formatter.field("game", &self.game);
		formatter.finish()
	}
}
/// See [`PartyActivityMatchmakerFindingLobby`](crate::model::PartyActivityMatchmakerFindingLobby)
pub mod party_activity_matchmaker_finding_lobby {
	/// A builder for [`PartyActivityMatchmakerFindingLobby`](crate::model::PartyActivityMatchmakerFindingLobby)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) game: std::option::Option<crate::model::GameHandle>,
	}
	impl Builder {
		/// A game handle.
		pub fn game(mut self, input: crate::model::GameHandle) -> Self {
			self.game = Some(input);
			self
		}
		/// A game handle.
		pub fn set_game(mut self, input: std::option::Option<crate::model::GameHandle>) -> Self {
			self.game = input;
			self
		}
		/// Consumes the builder and constructs a [`PartyActivityMatchmakerFindingLobby`](crate::model::PartyActivityMatchmakerFindingLobby)
		pub fn build(self) -> crate::model::PartyActivityMatchmakerFindingLobby {
			crate::model::PartyActivityMatchmakerFindingLobby { game: self.game }
		}
	}
}
impl PartyActivityMatchmakerFindingLobby {
	/// Creates a new builder-style object to manufacture [`PartyActivityMatchmakerFindingLobby`](crate::model::PartyActivityMatchmakerFindingLobby)
	pub fn builder() -> crate::model::party_activity_matchmaker_finding_lobby::Builder {
		crate::model::party_activity_matchmaker_finding_lobby::Builder::default()
	}
}

/// A party activity denoting that the party is idle.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PartyActivityIdle {}
impl std::fmt::Debug for PartyActivityIdle {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("PartyActivityIdle");
		formatter.finish()
	}
}
/// See [`PartyActivityIdle`](crate::model::PartyActivityIdle)
pub mod party_activity_idle {
	/// A builder for [`PartyActivityIdle`](crate::model::PartyActivityIdle)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {}
	impl Builder {
		/// Consumes the builder and constructs a [`PartyActivityIdle`](crate::model::PartyActivityIdle)
		pub fn build(self) -> crate::model::PartyActivityIdle {
			crate::model::PartyActivityIdle {}
		}
	}
}
impl PartyActivityIdle {
	/// Creates a new builder-style object to manufacture [`PartyActivityIdle`](crate::model::PartyActivityIdle)
	pub fn builder() -> crate::model::party_activity_idle::Builder {
		crate::model::party_activity_idle::Builder::default()
	}
}

/// Information about the identity's current status, party, and active game.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct IdentityPresence {
	/// RFC3339 timestamp.
	pub update_ts: std::option::Option<aws_smithy_types::DateTime>,
	/// The current status of an identity. This helps players understand if another player is currently playing or has their game in the background.
	pub status: std::option::Option<crate::model::IdentityStatus>,
	/// The game an identity is currently participating in.
	pub game_activity: std::option::Option<crate::model::IdentityGameActivity>,
}
impl IdentityPresence {
	/// RFC3339 timestamp.
	pub fn update_ts(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
		self.update_ts.as_ref()
	}
	/// The current status of an identity. This helps players understand if another player is currently playing or has their game in the background.
	pub fn status(&self) -> std::option::Option<&crate::model::IdentityStatus> {
		self.status.as_ref()
	}
	/// The game an identity is currently participating in.
	pub fn game_activity(&self) -> std::option::Option<&crate::model::IdentityGameActivity> {
		self.game_activity.as_ref()
	}
}
impl std::fmt::Debug for IdentityPresence {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("IdentityPresence");
		formatter.field("update_ts", &self.update_ts);
		formatter.field("status", &self.status);
		formatter.field("game_activity", &self.game_activity);
		formatter.finish()
	}
}
/// See [`IdentityPresence`](crate::model::IdentityPresence)
pub mod identity_presence {
	/// A builder for [`IdentityPresence`](crate::model::IdentityPresence)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) update_ts: std::option::Option<aws_smithy_types::DateTime>,
		pub(crate) status: std::option::Option<crate::model::IdentityStatus>,
		pub(crate) game_activity: std::option::Option<crate::model::IdentityGameActivity>,
	}
	impl Builder {
		/// RFC3339 timestamp.
		pub fn update_ts(mut self, input: aws_smithy_types::DateTime) -> Self {
			self.update_ts = Some(input);
			self
		}
		/// RFC3339 timestamp.
		pub fn set_update_ts(
			mut self,
			input: std::option::Option<aws_smithy_types::DateTime>,
		) -> Self {
			self.update_ts = input;
			self
		}
		/// The current status of an identity. This helps players understand if another player is currently playing or has their game in the background.
		pub fn status(mut self, input: crate::model::IdentityStatus) -> Self {
			self.status = Some(input);
			self
		}
		/// The current status of an identity. This helps players understand if another player is currently playing or has their game in the background.
		pub fn set_status(
			mut self,
			input: std::option::Option<crate::model::IdentityStatus>,
		) -> Self {
			self.status = input;
			self
		}
		/// The game an identity is currently participating in.
		pub fn game_activity(mut self, input: crate::model::IdentityGameActivity) -> Self {
			self.game_activity = Some(input);
			self
		}
		/// The game an identity is currently participating in.
		pub fn set_game_activity(
			mut self,
			input: std::option::Option<crate::model::IdentityGameActivity>,
		) -> Self {
			self.game_activity = input;
			self
		}
		/// Consumes the builder and constructs a [`IdentityPresence`](crate::model::IdentityPresence)
		pub fn build(self) -> crate::model::IdentityPresence {
			crate::model::IdentityPresence {
				update_ts: self.update_ts,
				status: self.status,
				game_activity: self.game_activity,
			}
		}
	}
}
impl IdentityPresence {
	/// Creates a new builder-style object to manufacture [`IdentityPresence`](crate::model::IdentityPresence)
	pub fn builder() -> crate::model::identity_presence::Builder {
		crate::model::identity_presence::Builder::default()
	}
}

/// The game an identity is currently participating in.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct IdentityGameActivity {
	/// A game handle.
	pub game: std::option::Option<crate::model::GameHandle>,
	/// A short activity message about the current game activity.
	pub message: std::option::Option<std::string::String>,
	/// JSON data seen by anyone.
	pub public_metadata: std::option::Option<aws_smithy_types::Document>,
	/// JSON data seen only by the given identity and their mutual followers.
	pub mutual_metadata: std::option::Option<aws_smithy_types::Document>,
}
impl IdentityGameActivity {
	/// A game handle.
	pub fn game(&self) -> std::option::Option<&crate::model::GameHandle> {
		self.game.as_ref()
	}
	/// A short activity message about the current game activity.
	pub fn message(&self) -> std::option::Option<&str> {
		self.message.as_deref()
	}
	/// JSON data seen by anyone.
	pub fn public_metadata(&self) -> std::option::Option<&aws_smithy_types::Document> {
		self.public_metadata.as_ref()
	}
	/// JSON data seen only by the given identity and their mutual followers.
	pub fn mutual_metadata(&self) -> std::option::Option<&aws_smithy_types::Document> {
		self.mutual_metadata.as_ref()
	}
}
impl std::fmt::Debug for IdentityGameActivity {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("IdentityGameActivity");
		formatter.field("game", &self.game);
		formatter.field("message", &self.message);
		formatter.field("public_metadata", &self.public_metadata);
		formatter.field("mutual_metadata", &self.mutual_metadata);
		formatter.finish()
	}
}
/// See [`IdentityGameActivity`](crate::model::IdentityGameActivity)
pub mod identity_game_activity {
	/// A builder for [`IdentityGameActivity`](crate::model::IdentityGameActivity)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) game: std::option::Option<crate::model::GameHandle>,
		pub(crate) message: std::option::Option<std::string::String>,
		pub(crate) public_metadata: std::option::Option<aws_smithy_types::Document>,
		pub(crate) mutual_metadata: std::option::Option<aws_smithy_types::Document>,
	}
	impl Builder {
		/// A game handle.
		pub fn game(mut self, input: crate::model::GameHandle) -> Self {
			self.game = Some(input);
			self
		}
		/// A game handle.
		pub fn set_game(mut self, input: std::option::Option<crate::model::GameHandle>) -> Self {
			self.game = input;
			self
		}
		/// A short activity message about the current game activity.
		pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
			self.message = Some(input.into());
			self
		}
		/// A short activity message about the current game activity.
		pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.message = input;
			self
		}
		/// JSON data seen by anyone.
		pub fn public_metadata(mut self, input: aws_smithy_types::Document) -> Self {
			self.public_metadata = Some(input);
			self
		}
		/// JSON data seen by anyone.
		pub fn set_public_metadata(
			mut self,
			input: std::option::Option<aws_smithy_types::Document>,
		) -> Self {
			self.public_metadata = input;
			self
		}
		/// JSON data seen only by the given identity and their mutual followers.
		pub fn mutual_metadata(mut self, input: aws_smithy_types::Document) -> Self {
			self.mutual_metadata = Some(input);
			self
		}
		/// JSON data seen only by the given identity and their mutual followers.
		pub fn set_mutual_metadata(
			mut self,
			input: std::option::Option<aws_smithy_types::Document>,
		) -> Self {
			self.mutual_metadata = input;
			self
		}
		/// Consumes the builder and constructs a [`IdentityGameActivity`](crate::model::IdentityGameActivity)
		pub fn build(self) -> crate::model::IdentityGameActivity {
			crate::model::IdentityGameActivity {
				game: self.game,
				message: self.message,
				public_metadata: self.public_metadata,
				mutual_metadata: self.mutual_metadata,
			}
		}
	}
}
impl IdentityGameActivity {
	/// Creates a new builder-style object to manufacture [`IdentityGameActivity`](crate::model::IdentityGameActivity)
	pub fn builder() -> crate::model::identity_game_activity::Builder {
		crate::model::identity_game_activity::Builder::default()
	}
}

/// The current status of an identity. This helps players understand if another
/// player is currently playing or has their game in the background.
#[non_exhaustive]
#[derive(
	std::clone::Clone,
	std::cmp::Eq,
	std::cmp::Ord,
	std::cmp::PartialEq,
	std::cmp::PartialOrd,
	std::fmt::Debug,
	std::hash::Hash,
)]
pub enum IdentityStatus {
	#[allow(missing_docs)] // documentation missing in model
	Away,
	#[allow(missing_docs)] // documentation missing in model
	Offline,
	#[allow(missing_docs)] // documentation missing in model
	Online,
	/// Unknown contains new variants that have been added since this code was generated.
	Unknown(String),
}
impl std::convert::From<&str> for IdentityStatus {
	fn from(s: &str) -> Self {
		match s {
			"away" => IdentityStatus::Away,
			"offline" => IdentityStatus::Offline,
			"online" => IdentityStatus::Online,
			other => IdentityStatus::Unknown(other.to_owned()),
		}
	}
}
impl std::str::FromStr for IdentityStatus {
	type Err = std::convert::Infallible;

	fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
		Ok(IdentityStatus::from(s))
	}
}
impl IdentityStatus {
	/// Returns the `&str` value of the enum member.
	pub fn as_str(&self) -> &str {
		match self {
			IdentityStatus::Away => "away",
			IdentityStatus::Offline => "offline",
			IdentityStatus::Online => "online",
			IdentityStatus::Unknown(s) => s.as_ref(),
		}
	}
	/// Returns all the `&str` values of the enum members.
	pub fn values() -> &'static [&'static str] {
		&["away", "offline", "online"]
	}
}
impl AsRef<str> for IdentityStatus {
	fn as_ref(&self) -> &str {
		self.as_str()
	}
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PartyPublicity {
	#[allow(missing_docs)] // documentation missing in model
	pub public: std::option::Option<crate::model::PartyPublicityLevel>,
	#[allow(missing_docs)] // documentation missing in model
	pub mutual_followers: std::option::Option<crate::model::PartyPublicityLevel>,
	#[allow(missing_docs)] // documentation missing in model
	pub groups: std::option::Option<crate::model::PartyPublicityLevel>,
}
impl PartyPublicity {
	#[allow(missing_docs)] // documentation missing in model
	pub fn public(&self) -> std::option::Option<&crate::model::PartyPublicityLevel> {
		self.public.as_ref()
	}
	#[allow(missing_docs)] // documentation missing in model
	pub fn mutual_followers(&self) -> std::option::Option<&crate::model::PartyPublicityLevel> {
		self.mutual_followers.as_ref()
	}
	#[allow(missing_docs)] // documentation missing in model
	pub fn groups(&self) -> std::option::Option<&crate::model::PartyPublicityLevel> {
		self.groups.as_ref()
	}
}
impl std::fmt::Debug for PartyPublicity {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("PartyPublicity");
		formatter.field("public", &self.public);
		formatter.field("mutual_followers", &self.mutual_followers);
		formatter.field("groups", &self.groups);
		formatter.finish()
	}
}
/// See [`PartyPublicity`](crate::model::PartyPublicity)
pub mod party_publicity {
	/// A builder for [`PartyPublicity`](crate::model::PartyPublicity)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) public: std::option::Option<crate::model::PartyPublicityLevel>,
		pub(crate) mutual_followers: std::option::Option<crate::model::PartyPublicityLevel>,
		pub(crate) groups: std::option::Option<crate::model::PartyPublicityLevel>,
	}
	impl Builder {
		#[allow(missing_docs)] // documentation missing in model
		pub fn public(mut self, input: crate::model::PartyPublicityLevel) -> Self {
			self.public = Some(input);
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn set_public(
			mut self,
			input: std::option::Option<crate::model::PartyPublicityLevel>,
		) -> Self {
			self.public = input;
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn mutual_followers(mut self, input: crate::model::PartyPublicityLevel) -> Self {
			self.mutual_followers = Some(input);
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn set_mutual_followers(
			mut self,
			input: std::option::Option<crate::model::PartyPublicityLevel>,
		) -> Self {
			self.mutual_followers = input;
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn groups(mut self, input: crate::model::PartyPublicityLevel) -> Self {
			self.groups = Some(input);
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn set_groups(
			mut self,
			input: std::option::Option<crate::model::PartyPublicityLevel>,
		) -> Self {
			self.groups = input;
			self
		}
		/// Consumes the builder and constructs a [`PartyPublicity`](crate::model::PartyPublicity)
		pub fn build(self) -> crate::model::PartyPublicity {
			crate::model::PartyPublicity {
				public: self.public,
				mutual_followers: self.mutual_followers,
				groups: self.groups,
			}
		}
	}
}
impl PartyPublicity {
	/// Creates a new builder-style object to manufacture [`PartyPublicity`](crate::model::PartyPublicity)
	pub fn builder() -> crate::model::party_publicity::Builder {
		crate::model::party_publicity::Builder::default()
	}
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(
	std::clone::Clone,
	std::cmp::Eq,
	std::cmp::Ord,
	std::cmp::PartialEq,
	std::cmp::PartialOrd,
	std::fmt::Debug,
	std::hash::Hash,
)]
pub enum PartyPublicityLevel {
	#[allow(missing_docs)] // documentation missing in model
	Join,
	#[allow(missing_docs)] // documentation missing in model
	None,
	#[allow(missing_docs)] // documentation missing in model
	View,
	/// Unknown contains new variants that have been added since this code was generated.
	Unknown(String),
}
impl std::convert::From<&str> for PartyPublicityLevel {
	fn from(s: &str) -> Self {
		match s {
			"join" => PartyPublicityLevel::Join,
			"none" => PartyPublicityLevel::None,
			"view" => PartyPublicityLevel::View,
			other => PartyPublicityLevel::Unknown(other.to_owned()),
		}
	}
}
impl std::str::FromStr for PartyPublicityLevel {
	type Err = std::convert::Infallible;

	fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
		Ok(PartyPublicityLevel::from(s))
	}
}
impl PartyPublicityLevel {
	/// Returns the `&str` value of the enum member.
	pub fn as_str(&self) -> &str {
		match self {
			PartyPublicityLevel::Join => "join",
			PartyPublicityLevel::None => "none",
			PartyPublicityLevel::View => "view",
			PartyPublicityLevel::Unknown(s) => s.as_ref(),
		}
	}
	/// Returns all the `&str` values of the enum members.
	pub fn values() -> &'static [&'static str] {
		&["join", "none", "view"]
	}
}
impl AsRef<str> for PartyPublicityLevel {
	fn as_ref(&self) -> &str {
		self.as_str()
	}
}

/// Represents methods of joining a party.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub enum JoinPartyInvite {
	/// A party invite alias. See `rivet.api.party.common#CreatePartyInviteConfig$alias` and `rivet.api.party#CreatePartyInvite$alias`.
	Alias(std::string::String),
	/// Requires the party publicity to this identity to be `rivet.party#PartyPublicityLevel$JOIN`.
	PartyId(std::string::String),
	/// A party invite token. See `rivet.api.party.common#CreatedInvite$token`.
	Token(std::string::String),
	/// The `Unknown` variant represents cases where new union variant was received. Consider upgrading the SDK to the latest available version.
	/// An unknown enum variant
	///
	/// _Note: If you encounter this error, consider upgrading your SDK to the latest version._
	/// The `Unknown` variant represents cases where the server sent a value that wasn't recognized
	/// by the client. This can happen when the server adds new functionality, but the client has not been updated.
	/// To investigate this, consider turning on debug logging to print the raw HTTP response.
	#[non_exhaustive]
	Unknown,
}
impl JoinPartyInvite {
	/// Tries to convert the enum instance into [`Alias`](crate::model::JoinPartyInvite::Alias), extracting the inner [`String`](std::string::String).
	/// Returns `Err(&Self)` if it can't be converted.
	pub fn as_alias(&self) -> std::result::Result<&std::string::String, &Self> {
		if let JoinPartyInvite::Alias(val) = &self {
			Ok(val)
		} else {
			Err(self)
		}
	}
	/// Returns true if this is a [`Alias`](crate::model::JoinPartyInvite::Alias).
	pub fn is_alias(&self) -> bool {
		self.as_alias().is_ok()
	}
	/// Tries to convert the enum instance into [`PartyId`](crate::model::JoinPartyInvite::PartyId), extracting the inner [`String`](std::string::String).
	/// Returns `Err(&Self)` if it can't be converted.
	pub fn as_party_id(&self) -> std::result::Result<&std::string::String, &Self> {
		if let JoinPartyInvite::PartyId(val) = &self {
			Ok(val)
		} else {
			Err(self)
		}
	}
	/// Returns true if this is a [`PartyId`](crate::model::JoinPartyInvite::PartyId).
	pub fn is_party_id(&self) -> bool {
		self.as_party_id().is_ok()
	}
	/// Tries to convert the enum instance into [`Token`](crate::model::JoinPartyInvite::Token), extracting the inner [`String`](std::string::String).
	/// Returns `Err(&Self)` if it can't be converted.
	pub fn as_token(&self) -> std::result::Result<&std::string::String, &Self> {
		if let JoinPartyInvite::Token(val) = &self {
			Ok(val)
		} else {
			Err(self)
		}
	}
	/// Returns true if this is a [`Token`](crate::model::JoinPartyInvite::Token).
	pub fn is_token(&self) -> bool {
		self.as_token().is_ok()
	}
	/// Returns true if the enum instance is the `Unknown` variant.
	pub fn is_unknown(&self) -> bool {
		matches!(self, Self::Unknown)
	}
}

/// Output from a created invite.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreatedInvite {
	/// A JSON Web Token. Slightly modified to include a description prefix and use Protobufs of JSON.
	pub token: std::option::Option<std::string::String>,
}
impl CreatedInvite {
	/// A JSON Web Token. Slightly modified to include a description prefix and use Protobufs of JSON.
	pub fn token(&self) -> std::option::Option<&str> {
		self.token.as_deref()
	}
}
impl std::fmt::Debug for CreatedInvite {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("CreatedInvite");
		formatter.field("token", &"*** Sensitive Data Redacted ***");
		formatter.finish()
	}
}
/// See [`CreatedInvite`](crate::model::CreatedInvite)
pub mod created_invite {
	/// A builder for [`CreatedInvite`](crate::model::CreatedInvite)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) token: std::option::Option<std::string::String>,
	}
	impl Builder {
		/// A JSON Web Token. Slightly modified to include a description prefix and use Protobufs of JSON.
		pub fn token(mut self, input: impl Into<std::string::String>) -> Self {
			self.token = Some(input.into());
			self
		}
		/// A JSON Web Token. Slightly modified to include a description prefix and use Protobufs of JSON.
		pub fn set_token(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.token = input;
			self
		}
		/// Consumes the builder and constructs a [`CreatedInvite`](crate::model::CreatedInvite)
		pub fn build(self) -> crate::model::CreatedInvite {
			crate::model::CreatedInvite { token: self.token }
		}
	}
}
impl CreatedInvite {
	/// Creates a new builder-style object to manufacture [`CreatedInvite`](crate::model::CreatedInvite)
	pub fn builder() -> crate::model::created_invite::Builder {
		crate::model::created_invite::Builder::default()
	}
}

/// Configuration for creating a party invite.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreatePartyInviteConfig {
	/// An alias used to join a given party. This alias must be unique for all invites for your game. Pass this alias to `rivet.api.party.common#CreatedInvite$alias` to consume the invite.
	pub alias: std::option::Option<std::string::String>,
}
impl CreatePartyInviteConfig {
	/// An alias used to join a given party. This alias must be unique for all invites for your game. Pass this alias to `rivet.api.party.common#CreatedInvite$alias` to consume the invite.
	pub fn alias(&self) -> std::option::Option<&str> {
		self.alias.as_deref()
	}
}
impl std::fmt::Debug for CreatePartyInviteConfig {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("CreatePartyInviteConfig");
		formatter.field("alias", &self.alias);
		formatter.finish()
	}
}
/// See [`CreatePartyInviteConfig`](crate::model::CreatePartyInviteConfig)
pub mod create_party_invite_config {
	/// A builder for [`CreatePartyInviteConfig`](crate::model::CreatePartyInviteConfig)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) alias: std::option::Option<std::string::String>,
	}
	impl Builder {
		/// An alias used to join a given party. This alias must be unique for all invites for your game. Pass this alias to `rivet.api.party.common#CreatedInvite$alias` to consume the invite.
		pub fn alias(mut self, input: impl Into<std::string::String>) -> Self {
			self.alias = Some(input.into());
			self
		}
		/// An alias used to join a given party. This alias must be unique for all invites for your game. Pass this alias to `rivet.api.party.common#CreatedInvite$alias` to consume the invite.
		pub fn set_alias(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.alias = input;
			self
		}
		/// Consumes the builder and constructs a [`CreatePartyInviteConfig`](crate::model::CreatePartyInviteConfig)
		pub fn build(self) -> crate::model::CreatePartyInviteConfig {
			crate::model::CreatePartyInviteConfig { alias: self.alias }
		}
	}
}
impl CreatePartyInviteConfig {
	/// Creates a new builder-style object to manufacture [`CreatePartyInviteConfig`](crate::model::CreatePartyInviteConfig)
	pub fn builder() -> crate::model::create_party_invite_config::Builder {
		crate::model::create_party_invite_config::Builder::default()
	}
}

/// Publicity configuration for creating a party. Null values will default
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreatePartyPublicityConfig {
	/// Defaults to `rivet.party#PartyPublicityLevel$VIEW`.
	pub public: std::option::Option<crate::model::PartyPublicityLevel>,
	/// Defaults to `rivet.party#PartyPublicityLevel$JOIN`.
	pub mutual_followers: std::option::Option<crate::model::PartyPublicityLevel>,
	/// Defaults to `rivet.party#PartyPublicityLevel$VIEW`.
	pub groups: std::option::Option<crate::model::PartyPublicityLevel>,
}
impl CreatePartyPublicityConfig {
	/// Defaults to `rivet.party#PartyPublicityLevel$VIEW`.
	pub fn public(&self) -> std::option::Option<&crate::model::PartyPublicityLevel> {
		self.public.as_ref()
	}
	/// Defaults to `rivet.party#PartyPublicityLevel$JOIN`.
	pub fn mutual_followers(&self) -> std::option::Option<&crate::model::PartyPublicityLevel> {
		self.mutual_followers.as_ref()
	}
	/// Defaults to `rivet.party#PartyPublicityLevel$VIEW`.
	pub fn groups(&self) -> std::option::Option<&crate::model::PartyPublicityLevel> {
		self.groups.as_ref()
	}
}
impl std::fmt::Debug for CreatePartyPublicityConfig {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("CreatePartyPublicityConfig");
		formatter.field("public", &self.public);
		formatter.field("mutual_followers", &self.mutual_followers);
		formatter.field("groups", &self.groups);
		formatter.finish()
	}
}
/// See [`CreatePartyPublicityConfig`](crate::model::CreatePartyPublicityConfig)
pub mod create_party_publicity_config {
	/// A builder for [`CreatePartyPublicityConfig`](crate::model::CreatePartyPublicityConfig)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) public: std::option::Option<crate::model::PartyPublicityLevel>,
		pub(crate) mutual_followers: std::option::Option<crate::model::PartyPublicityLevel>,
		pub(crate) groups: std::option::Option<crate::model::PartyPublicityLevel>,
	}
	impl Builder {
		/// Defaults to `rivet.party#PartyPublicityLevel$VIEW`.
		pub fn public(mut self, input: crate::model::PartyPublicityLevel) -> Self {
			self.public = Some(input);
			self
		}
		/// Defaults to `rivet.party#PartyPublicityLevel$VIEW`.
		pub fn set_public(
			mut self,
			input: std::option::Option<crate::model::PartyPublicityLevel>,
		) -> Self {
			self.public = input;
			self
		}
		/// Defaults to `rivet.party#PartyPublicityLevel$JOIN`.
		pub fn mutual_followers(mut self, input: crate::model::PartyPublicityLevel) -> Self {
			self.mutual_followers = Some(input);
			self
		}
		/// Defaults to `rivet.party#PartyPublicityLevel$JOIN`.
		pub fn set_mutual_followers(
			mut self,
			input: std::option::Option<crate::model::PartyPublicityLevel>,
		) -> Self {
			self.mutual_followers = input;
			self
		}
		/// Defaults to `rivet.party#PartyPublicityLevel$VIEW`.
		pub fn groups(mut self, input: crate::model::PartyPublicityLevel) -> Self {
			self.groups = Some(input);
			self
		}
		/// Defaults to `rivet.party#PartyPublicityLevel$VIEW`.
		pub fn set_groups(
			mut self,
			input: std::option::Option<crate::model::PartyPublicityLevel>,
		) -> Self {
			self.groups = input;
			self
		}
		/// Consumes the builder and constructs a [`CreatePartyPublicityConfig`](crate::model::CreatePartyPublicityConfig)
		pub fn build(self) -> crate::model::CreatePartyPublicityConfig {
			crate::model::CreatePartyPublicityConfig {
				public: self.public,
				mutual_followers: self.mutual_followers,
				groups: self.groups,
			}
		}
	}
}
impl CreatePartyPublicityConfig {
	/// Creates a new builder-style object to manufacture [`CreatePartyPublicityConfig`](crate::model::CreatePartyPublicityConfig)
	pub fn builder() -> crate::model::create_party_publicity_config::Builder {
		crate::model::create_party_publicity_config::Builder::default()
	}
}

/// Provided by watchable endpoints used in blocking loops.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct WatchResponse {
	/// Index indicating the version of the data responded. Pas this to `rivet.common#WatchQuery` to block and wait for the next response.
	pub index: std::option::Option<std::string::String>,
}
impl WatchResponse {
	/// Index indicating the version of the data responded. Pas this to `rivet.common#WatchQuery` to block and wait for the next response.
	pub fn index(&self) -> std::option::Option<&str> {
		self.index.as_deref()
	}
}
impl std::fmt::Debug for WatchResponse {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("WatchResponse");
		formatter.field("index", &self.index);
		formatter.finish()
	}
}
/// See [`WatchResponse`](crate::model::WatchResponse)
pub mod watch_response {
	/// A builder for [`WatchResponse`](crate::model::WatchResponse)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) index: std::option::Option<std::string::String>,
	}
	impl Builder {
		/// Index indicating the version of the data responded. Pas this to `rivet.common#WatchQuery` to block and wait for the next response.
		pub fn index(mut self, input: impl Into<std::string::String>) -> Self {
			self.index = Some(input.into());
			self
		}
		/// Index indicating the version of the data responded. Pas this to `rivet.common#WatchQuery` to block and wait for the next response.
		pub fn set_index(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.index = input;
			self
		}
		/// Consumes the builder and constructs a [`WatchResponse`](crate::model::WatchResponse)
		pub fn build(self) -> crate::model::WatchResponse {
			crate::model::WatchResponse { index: self.index }
		}
	}
}
impl WatchResponse {
	/// Creates a new builder-style object to manufacture [`WatchResponse`](crate::model::WatchResponse)
	pub fn builder() -> crate::model::watch_response::Builder {
		crate::model::watch_response::Builder::default()
	}
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PartyProfile {
	/// A universally unique identifier.
	pub party_id: std::option::Option<std::string::String>,
	/// RFC3339 timestamp.
	pub create_ts: std::option::Option<aws_smithy_types::DateTime>,
	/// A union representing the activity of a given party.
	pub activity: std::option::Option<crate::model::PartyActivity>,
	/// External links for a party.
	pub external: std::option::Option<crate::model::PartyExternalLinks>,
	#[allow(missing_docs)] // documentation missing in model
	pub publicity: std::option::Option<crate::model::PartyPublicity>,
	/// Unsigned 32 bit integer.
	pub party_size: std::option::Option<i32>,
	/// A list of party members.
	pub members: std::option::Option<std::vec::Vec<crate::model::PartyMemberSummary>>,
	/// A universally unique identifier.
	pub thread_id: std::option::Option<std::string::String>,
	/// A list of party invites.
	pub invites: std::option::Option<std::vec::Vec<crate::model::PartyInvite>>,
}
impl PartyProfile {
	/// A universally unique identifier.
	pub fn party_id(&self) -> std::option::Option<&str> {
		self.party_id.as_deref()
	}
	/// RFC3339 timestamp.
	pub fn create_ts(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
		self.create_ts.as_ref()
	}
	/// A union representing the activity of a given party.
	pub fn activity(&self) -> std::option::Option<&crate::model::PartyActivity> {
		self.activity.as_ref()
	}
	/// External links for a party.
	pub fn external(&self) -> std::option::Option<&crate::model::PartyExternalLinks> {
		self.external.as_ref()
	}
	#[allow(missing_docs)] // documentation missing in model
	pub fn publicity(&self) -> std::option::Option<&crate::model::PartyPublicity> {
		self.publicity.as_ref()
	}
	/// Unsigned 32 bit integer.
	pub fn party_size(&self) -> std::option::Option<i32> {
		self.party_size
	}
	/// A list of party members.
	pub fn members(&self) -> std::option::Option<&[crate::model::PartyMemberSummary]> {
		self.members.as_deref()
	}
	/// A universally unique identifier.
	pub fn thread_id(&self) -> std::option::Option<&str> {
		self.thread_id.as_deref()
	}
	/// A list of party invites.
	pub fn invites(&self) -> std::option::Option<&[crate::model::PartyInvite]> {
		self.invites.as_deref()
	}
}
impl std::fmt::Debug for PartyProfile {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("PartyProfile");
		formatter.field("party_id", &self.party_id);
		formatter.field("create_ts", &self.create_ts);
		formatter.field("activity", &self.activity);
		formatter.field("external", &self.external);
		formatter.field("publicity", &self.publicity);
		formatter.field("party_size", &self.party_size);
		formatter.field("members", &self.members);
		formatter.field("thread_id", &self.thread_id);
		formatter.field("invites", &self.invites);
		formatter.finish()
	}
}
/// See [`PartyProfile`](crate::model::PartyProfile)
pub mod party_profile {
	/// A builder for [`PartyProfile`](crate::model::PartyProfile)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) party_id: std::option::Option<std::string::String>,
		pub(crate) create_ts: std::option::Option<aws_smithy_types::DateTime>,
		pub(crate) activity: std::option::Option<crate::model::PartyActivity>,
		pub(crate) external: std::option::Option<crate::model::PartyExternalLinks>,
		pub(crate) publicity: std::option::Option<crate::model::PartyPublicity>,
		pub(crate) party_size: std::option::Option<i32>,
		pub(crate) members: std::option::Option<std::vec::Vec<crate::model::PartyMemberSummary>>,
		pub(crate) thread_id: std::option::Option<std::string::String>,
		pub(crate) invites: std::option::Option<std::vec::Vec<crate::model::PartyInvite>>,
	}
	impl Builder {
		/// A universally unique identifier.
		pub fn party_id(mut self, input: impl Into<std::string::String>) -> Self {
			self.party_id = Some(input.into());
			self
		}
		/// A universally unique identifier.
		pub fn set_party_id(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.party_id = input;
			self
		}
		/// RFC3339 timestamp.
		pub fn create_ts(mut self, input: aws_smithy_types::DateTime) -> Self {
			self.create_ts = Some(input);
			self
		}
		/// RFC3339 timestamp.
		pub fn set_create_ts(
			mut self,
			input: std::option::Option<aws_smithy_types::DateTime>,
		) -> Self {
			self.create_ts = input;
			self
		}
		/// A union representing the activity of a given party.
		pub fn activity(mut self, input: crate::model::PartyActivity) -> Self {
			self.activity = Some(input);
			self
		}
		/// A union representing the activity of a given party.
		pub fn set_activity(
			mut self,
			input: std::option::Option<crate::model::PartyActivity>,
		) -> Self {
			self.activity = input;
			self
		}
		/// External links for a party.
		pub fn external(mut self, input: crate::model::PartyExternalLinks) -> Self {
			self.external = Some(input);
			self
		}
		/// External links for a party.
		pub fn set_external(
			mut self,
			input: std::option::Option<crate::model::PartyExternalLinks>,
		) -> Self {
			self.external = input;
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn publicity(mut self, input: crate::model::PartyPublicity) -> Self {
			self.publicity = Some(input);
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn set_publicity(
			mut self,
			input: std::option::Option<crate::model::PartyPublicity>,
		) -> Self {
			self.publicity = input;
			self
		}
		/// Unsigned 32 bit integer.
		pub fn party_size(mut self, input: i32) -> Self {
			self.party_size = Some(input);
			self
		}
		/// Unsigned 32 bit integer.
		pub fn set_party_size(mut self, input: std::option::Option<i32>) -> Self {
			self.party_size = input;
			self
		}
		/// Appends an item to `members`.
		///
		/// To override the contents of this collection use [`set_members`](Self::set_members).
		///
		/// A list of party members.
		pub fn members(mut self, input: crate::model::PartyMemberSummary) -> Self {
			let mut v = self.members.unwrap_or_default();
			v.push(input);
			self.members = Some(v);
			self
		}
		/// A list of party members.
		pub fn set_members(
			mut self,
			input: std::option::Option<std::vec::Vec<crate::model::PartyMemberSummary>>,
		) -> Self {
			self.members = input;
			self
		}
		/// A universally unique identifier.
		pub fn thread_id(mut self, input: impl Into<std::string::String>) -> Self {
			self.thread_id = Some(input.into());
			self
		}
		/// A universally unique identifier.
		pub fn set_thread_id(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.thread_id = input;
			self
		}
		/// Appends an item to `invites`.
		///
		/// To override the contents of this collection use [`set_invites`](Self::set_invites).
		///
		/// A list of party invites.
		pub fn invites(mut self, input: crate::model::PartyInvite) -> Self {
			let mut v = self.invites.unwrap_or_default();
			v.push(input);
			self.invites = Some(v);
			self
		}
		/// A list of party invites.
		pub fn set_invites(
			mut self,
			input: std::option::Option<std::vec::Vec<crate::model::PartyInvite>>,
		) -> Self {
			self.invites = input;
			self
		}
		/// Consumes the builder and constructs a [`PartyProfile`](crate::model::PartyProfile)
		pub fn build(self) -> crate::model::PartyProfile {
			crate::model::PartyProfile {
				party_id: self.party_id,
				create_ts: self.create_ts,
				activity: self.activity,
				external: self.external,
				publicity: self.publicity,
				party_size: self.party_size,
				members: self.members,
				thread_id: self.thread_id,
				invites: self.invites,
			}
		}
	}
}
impl PartyProfile {
	/// Creates a new builder-style object to manufacture [`PartyProfile`](crate::model::PartyProfile)
	pub fn builder() -> crate::model::party_profile::Builder {
		crate::model::party_profile::Builder::default()
	}
}

/// A party invite.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PartyInvite {
	/// A universally unique identifier.
	pub invite_id: std::option::Option<std::string::String>,
	/// RFC3339 timestamp.
	pub create_ts: std::option::Option<aws_smithy_types::DateTime>,
	/// A JSON Web Token. Slightly modified to include a description prefix and use Protobufs of JSON.
	pub token: std::option::Option<std::string::String>,
	/// An alias used to join a given party.
	pub alias: std::option::Option<crate::model::PartyInviteAlias>,
	/// Extenral links for a party invite.
	pub external: std::option::Option<crate::model::PartyInviteExternalLinks>,
}
impl PartyInvite {
	/// A universally unique identifier.
	pub fn invite_id(&self) -> std::option::Option<&str> {
		self.invite_id.as_deref()
	}
	/// RFC3339 timestamp.
	pub fn create_ts(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
		self.create_ts.as_ref()
	}
	/// A JSON Web Token. Slightly modified to include a description prefix and use Protobufs of JSON.
	pub fn token(&self) -> std::option::Option<&str> {
		self.token.as_deref()
	}
	/// An alias used to join a given party.
	pub fn alias(&self) -> std::option::Option<&crate::model::PartyInviteAlias> {
		self.alias.as_ref()
	}
	/// Extenral links for a party invite.
	pub fn external(&self) -> std::option::Option<&crate::model::PartyInviteExternalLinks> {
		self.external.as_ref()
	}
}
impl std::fmt::Debug for PartyInvite {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("PartyInvite");
		formatter.field("invite_id", &self.invite_id);
		formatter.field("create_ts", &self.create_ts);
		formatter.field("token", &"*** Sensitive Data Redacted ***");
		formatter.field("alias", &self.alias);
		formatter.field("external", &self.external);
		formatter.finish()
	}
}
/// See [`PartyInvite`](crate::model::PartyInvite)
pub mod party_invite {
	/// A builder for [`PartyInvite`](crate::model::PartyInvite)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) invite_id: std::option::Option<std::string::String>,
		pub(crate) create_ts: std::option::Option<aws_smithy_types::DateTime>,
		pub(crate) token: std::option::Option<std::string::String>,
		pub(crate) alias: std::option::Option<crate::model::PartyInviteAlias>,
		pub(crate) external: std::option::Option<crate::model::PartyInviteExternalLinks>,
	}
	impl Builder {
		/// A universally unique identifier.
		pub fn invite_id(mut self, input: impl Into<std::string::String>) -> Self {
			self.invite_id = Some(input.into());
			self
		}
		/// A universally unique identifier.
		pub fn set_invite_id(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.invite_id = input;
			self
		}
		/// RFC3339 timestamp.
		pub fn create_ts(mut self, input: aws_smithy_types::DateTime) -> Self {
			self.create_ts = Some(input);
			self
		}
		/// RFC3339 timestamp.
		pub fn set_create_ts(
			mut self,
			input: std::option::Option<aws_smithy_types::DateTime>,
		) -> Self {
			self.create_ts = input;
			self
		}
		/// A JSON Web Token. Slightly modified to include a description prefix and use Protobufs of JSON.
		pub fn token(mut self, input: impl Into<std::string::String>) -> Self {
			self.token = Some(input.into());
			self
		}
		/// A JSON Web Token. Slightly modified to include a description prefix and use Protobufs of JSON.
		pub fn set_token(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.token = input;
			self
		}
		/// An alias used to join a given party.
		pub fn alias(mut self, input: crate::model::PartyInviteAlias) -> Self {
			self.alias = Some(input);
			self
		}
		/// An alias used to join a given party.
		pub fn set_alias(
			mut self,
			input: std::option::Option<crate::model::PartyInviteAlias>,
		) -> Self {
			self.alias = input;
			self
		}
		/// Extenral links for a party invite.
		pub fn external(mut self, input: crate::model::PartyInviteExternalLinks) -> Self {
			self.external = Some(input);
			self
		}
		/// Extenral links for a party invite.
		pub fn set_external(
			mut self,
			input: std::option::Option<crate::model::PartyInviteExternalLinks>,
		) -> Self {
			self.external = input;
			self
		}
		/// Consumes the builder and constructs a [`PartyInvite`](crate::model::PartyInvite)
		pub fn build(self) -> crate::model::PartyInvite {
			crate::model::PartyInvite {
				invite_id: self.invite_id,
				create_ts: self.create_ts,
				token: self.token,
				alias: self.alias,
				external: self.external,
			}
		}
	}
}
impl PartyInvite {
	/// Creates a new builder-style object to manufacture [`PartyInvite`](crate::model::PartyInvite)
	pub fn builder() -> crate::model::party_invite::Builder {
		crate::model::party_invite::Builder::default()
	}
}

/// Extenral links for a party invite.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PartyInviteExternalLinks {
	/// The invite link used to join this party from an external site.
	pub invite: std::option::Option<std::string::String>,
}
impl PartyInviteExternalLinks {
	/// The invite link used to join this party from an external site.
	pub fn invite(&self) -> std::option::Option<&str> {
		self.invite.as_deref()
	}
}
impl std::fmt::Debug for PartyInviteExternalLinks {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("PartyInviteExternalLinks");
		formatter.field("invite", &self.invite);
		formatter.finish()
	}
}
/// See [`PartyInviteExternalLinks`](crate::model::PartyInviteExternalLinks)
pub mod party_invite_external_links {
	/// A builder for [`PartyInviteExternalLinks`](crate::model::PartyInviteExternalLinks)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) invite: std::option::Option<std::string::String>,
	}
	impl Builder {
		/// The invite link used to join this party from an external site.
		pub fn invite(mut self, input: impl Into<std::string::String>) -> Self {
			self.invite = Some(input.into());
			self
		}
		/// The invite link used to join this party from an external site.
		pub fn set_invite(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.invite = input;
			self
		}
		/// Consumes the builder and constructs a [`PartyInviteExternalLinks`](crate::model::PartyInviteExternalLinks)
		pub fn build(self) -> crate::model::PartyInviteExternalLinks {
			crate::model::PartyInviteExternalLinks {
				invite: self.invite,
			}
		}
	}
}
impl PartyInviteExternalLinks {
	/// Creates a new builder-style object to manufacture [`PartyInviteExternalLinks`](crate::model::PartyInviteExternalLinks)
	pub fn builder() -> crate::model::party_invite_external_links::Builder {
		crate::model::party_invite_external_links::Builder::default()
	}
}

/// An alias used to join a given party.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PartyInviteAlias {
	/// A universally unique identifier.
	pub namespace_id: std::option::Option<std::string::String>,
	/// The alias used to join a given party.
	pub alias: std::option::Option<std::string::String>,
}
impl PartyInviteAlias {
	/// A universally unique identifier.
	pub fn namespace_id(&self) -> std::option::Option<&str> {
		self.namespace_id.as_deref()
	}
	/// The alias used to join a given party.
	pub fn alias(&self) -> std::option::Option<&str> {
		self.alias.as_deref()
	}
}
impl std::fmt::Debug for PartyInviteAlias {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("PartyInviteAlias");
		formatter.field("namespace_id", &self.namespace_id);
		formatter.field("alias", &self.alias);
		formatter.finish()
	}
}
/// See [`PartyInviteAlias`](crate::model::PartyInviteAlias)
pub mod party_invite_alias {
	/// A builder for [`PartyInviteAlias`](crate::model::PartyInviteAlias)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) namespace_id: std::option::Option<std::string::String>,
		pub(crate) alias: std::option::Option<std::string::String>,
	}
	impl Builder {
		/// A universally unique identifier.
		pub fn namespace_id(mut self, input: impl Into<std::string::String>) -> Self {
			self.namespace_id = Some(input.into());
			self
		}
		/// A universally unique identifier.
		pub fn set_namespace_id(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.namespace_id = input;
			self
		}
		/// The alias used to join a given party.
		pub fn alias(mut self, input: impl Into<std::string::String>) -> Self {
			self.alias = Some(input.into());
			self
		}
		/// The alias used to join a given party.
		pub fn set_alias(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.alias = input;
			self
		}
		/// Consumes the builder and constructs a [`PartyInviteAlias`](crate::model::PartyInviteAlias)
		pub fn build(self) -> crate::model::PartyInviteAlias {
			crate::model::PartyInviteAlias {
				namespace_id: self.namespace_id,
				alias: self.alias,
			}
		}
	}
}
impl PartyInviteAlias {
	/// Creates a new builder-style object to manufacture [`PartyInviteAlias`](crate::model::PartyInviteAlias)
	pub fn builder() -> crate::model::party_invite_alias::Builder {
		crate::model::party_invite_alias::Builder::default()
	}
}