// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
#[derive(Debug)]
pub(crate) struct Handle<C, M, R = aws_smithy_client::retry::Standard> {
pub(crate) client: aws_smithy_client::Client<C, M, R>,
pub(crate) conf: crate::Config,
}
/// An ergonomic service client for `PartyService`.
///
/// This client allows ergonomic access to a `PartyService`-shaped service.
/// Each method corresponds to an endpoint defined in the service's Smithy model,
/// and the request and response shapes are auto-generated from that same model.
///
/// # Constructing a Client
///
/// To construct a client, you need a few different things:
///
/// - A [`Config`](crate::Config) that specifies additional configuration
/// required by the service.
/// - A connector (`C`) that specifies how HTTP requests are translated
/// into HTTP responses. This will typically be an HTTP client (like
/// `hyper`), though you can also substitute in your own, like a mock
/// mock connector for testing.
/// - A "middleware" (`M`) that modifies requests prior to them being
/// sent to the request. Most commonly, middleware will decide what
/// endpoint the requests should be sent to, as well as perform
/// authentication and authorization of requests (such as SigV4).
/// You can also have middleware that performs request/response
/// tracing, throttling, or other middleware-like tasks.
/// - A retry policy (`R`) that dictates the behavior for requests that
/// fail and should (potentially) be retried. The default type is
/// generally what you want, as it implements a well-vetted retry
/// policy implemented in [`RetryMode::Standard`](aws_smithy_types::retry::RetryMode::Standard).
///
/// To construct a client, you will generally want to call
/// [`Client::with_config`], which takes a [`aws_smithy_client::Client`] (a
/// Smithy client that isn't specialized to a particular service),
/// and a [`Config`](crate::Config). Both of these are constructed using
/// the [builder pattern] where you first construct a `Builder` type,
/// then configure it with the necessary parameters, and then call
/// `build` to construct the finalized output type. The
/// [`aws_smithy_client::Client`] builder is re-exported in this crate as
/// [`Builder`] for convenience.
///
/// In _most_ circumstances, you will want to use the following pattern
/// to construct a client:
///
/// ```
/// use rivet_party::{Builder, Client, Config};
/// let raw_client =
/// Builder::dyn_https()
/// # /*
/// .middleware(/* discussed below */)
/// # */
/// # .middleware_fn(|r| r)
/// .build();
/// let config = Config::builder().build();
/// let client = Client::with_config(raw_client, config);
/// ```
///
/// For the middleware, you'll want to use whatever matches the
/// routing, authentication and authorization required by the target
/// service. For example, for the standard AWS SDK which uses
/// [SigV4-signed requests], the middleware looks like this:
///
// Ignored as otherwise we'd need to pull in all these dev-dependencies.
/// ```rust,ignore
/// use aws_endpoint::AwsEndpointStage;
/// use aws_http::auth::CredentialsStage;
/// use aws_http::recursion_detection::RecursionDetectionStage;
/// use aws_http::user_agent::UserAgentStage;
/// use aws_sig_auth::middleware::SigV4SigningStage;
/// use aws_sig_auth::signer::SigV4Signer;
/// use aws_smithy_client::retry::Config as RetryConfig;
/// use aws_smithy_http_tower::map_request::{AsyncMapRequestLayer, MapRequestLayer};
/// use std::fmt::Debug;
/// use tower::layer::util::{Identity, Stack};
/// use tower::ServiceBuilder;
///
/// type AwsMiddlewareStack = Stack<
/// MapRequestLayer<RecursionDetectionStage>,
/// Stack<
/// MapRequestLayer<SigV4SigningStage>,
/// Stack<
/// AsyncMapRequestLayer<CredentialsStage>,
/// Stack<
/// MapRequestLayer<UserAgentStage>,
/// Stack<MapRequestLayer<AwsEndpointStage>, Identity>,
/// >,
/// >,
/// >,
/// >;
///
/// /// AWS Middleware Stack
/// ///
/// /// This implements the middleware stack for this service. It will:
/// /// 1. Load credentials asynchronously into the property bag
/// /// 2. Sign the request with SigV4
/// /// 3. Resolve an Endpoint for the request
/// /// 4. Add a user agent to the request
/// #[derive(Debug, Default, Clone)]
/// #[non_exhaustive]
/// pub struct AwsMiddleware;
///
/// impl AwsMiddleware {
/// /// Create a new `AwsMiddleware` stack
/// ///
/// /// Note: `AwsMiddleware` holds no state.
/// pub fn new() -> Self {
/// AwsMiddleware::default()
/// }
/// }
///
/// // define the middleware stack in a non-generic location to reduce code bloat.
/// fn base() -> ServiceBuilder<AwsMiddlewareStack> {
/// let credential_provider = AsyncMapRequestLayer::for_mapper(CredentialsStage::new());
/// let signer = MapRequestLayer::for_mapper(SigV4SigningStage::new(SigV4Signer::new()));
/// let endpoint_resolver = MapRequestLayer::for_mapper(AwsEndpointStage);
/// let user_agent = MapRequestLayer::for_mapper(UserAgentStage::new());
/// let recursion_detection = MapRequestLayer::for_mapper(RecursionDetectionStage::new());
/// // These layers can be considered as occurring in order, that is:
/// // 1. Resolve an endpoint
/// // 2. Add a user agent
/// // 3. Acquire credentials
/// // 4. Sign with credentials
/// // (5. Dispatch over the wire)
/// ServiceBuilder::new()
/// .layer(endpoint_resolver)
/// .layer(user_agent)
/// .layer(credential_provider)
/// .layer(signer)
/// .layer(recursion_detection)
/// }
///
/// impl<S> tower::Layer<S> for AwsMiddleware {
/// type Service = <AwsMiddlewareStack as tower::Layer<S>>::Service;
///
/// fn layer(&self, inner: S) -> Self::Service {
/// base().service(inner)
/// }
/// }
/// ```
///
/// # Using a Client
///
/// Once you have a client set up, you can access the service's endpoints
/// by calling the appropriate method on [`Client`]. Each such method
/// returns a request builder for that endpoint, with methods for setting
/// the various fields of the request. Once your request is complete, use
/// the `send` method to send the request. `send` returns a future, which
/// you then have to `.await` to get the service's response.
///
/// [builder pattern]: https://rust-lang.github.io/api-guidelines/type-safety.html#c-builder
/// [SigV4-signed requests]: https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html
#[derive(std::fmt::Debug)]
pub struct Client<C, M, R = aws_smithy_client::retry::Standard> {
handle: std::sync::Arc<Handle<C, M, R>>,
}
impl<C, M, R> std::clone::Clone for Client<C, M, R> {
fn clone(&self) -> Self {
Self {
handle: self.handle.clone(),
}
}
}
#[doc(inline)]
pub use aws_smithy_client::Builder;
impl<C, M, R> From<aws_smithy_client::Client<C, M, R>> for Client<C, M, R> {
fn from(client: aws_smithy_client::Client<C, M, R>) -> Self {
Self::with_config(client, crate::Config::builder().build())
}
}
impl<C, M, R> Client<C, M, R> {
/// Creates a client with the given service configuration.
pub fn with_config(client: aws_smithy_client::Client<C, M, R>, conf: crate::Config) -> Self {
Self {
handle: std::sync::Arc::new(Handle { client, conf }),
}
}
/// Returns the client's configuration.
pub fn conf(&self) -> &crate::Config {
&self.handle.conf
}
}
impl<C, M, R> Client<C, M, R>
where
C: aws_smithy_client::bounds::SmithyConnector,
M: aws_smithy_client::bounds::SmithyMiddleware<C>,
R: aws_smithy_client::retry::NewRequestPolicy,
{
/// Constructs a fluent builder for the [`CreateParty`](crate::client::fluent_builders::CreateParty) operation.
///
/// - The fluent builder is configurable:
/// - [`party_size(i32)`](crate::client::fluent_builders::CreateParty::party_size) / [`set_party_size(Option<i32>)`](crate::client::fluent_builders::CreateParty::set_party_size): How many members can join the party. If using this party with the matchmaker, this number should be less than or equal to your party player limit. Super large parties may not be able to fit insite a lobby and be unable to join the game.
/// - [`publicity(CreatePartyPublicityConfig)`](crate::client::fluent_builders::CreateParty::publicity) / [`set_publicity(Option<CreatePartyPublicityConfig>)`](crate::client::fluent_builders::CreateParty::set_publicity): Publicity configuration for creating a party. Null values will default
/// - [`invites(Vec<CreatePartyInviteConfig>)`](crate::client::fluent_builders::CreateParty::invites) / [`set_invites(Option<Vec<CreatePartyInviteConfig>>)`](crate::client::fluent_builders::CreateParty::set_invites): (undocumented)
/// - [`matchmaker_current_player_token(impl Into<String>)`](crate::client::fluent_builders::CreateParty::matchmaker_current_player_token) / [`set_matchmaker_current_player_token(Option<String>)`](crate::client::fluent_builders::CreateParty::set_matchmaker_current_player_token): If the player is currently in the lobby, pass the token from `rivet.matchmaker#MatchmakerLobbyJoinInfoPlayer$token`. This will prevent issuing a new player token and automatically set the party state to the player's current lobby.
/// - On success, responds with [`CreatePartyOutput`](crate::output::CreatePartyOutput) with field(s):
/// - [`party_id(Option<String>)`](crate::output::CreatePartyOutput::party_id): A universally unique identifier.
/// - [`invites(Option<Vec<CreatedInvite>>)`](crate::output::CreatePartyOutput::invites): (undocumented)
/// - On failure, responds with [`SdkError<CreatePartyError>`](crate::error::CreatePartyError)
pub fn create_party(&self) -> fluent_builders::CreateParty<C, M, R> {
fluent_builders::CreateParty::new(self.handle.clone())
}
/// Constructs a fluent builder for the [`CreatePartyInvite`](crate::client::fluent_builders::CreatePartyInvite) operation.
///
/// - The fluent builder is configurable:
/// - [`alias(impl Into<String>)`](crate::client::fluent_builders::CreatePartyInvite::alias) / [`set_alias(Option<String>)`](crate::client::fluent_builders::CreatePartyInvite::set_alias): An alias used to join a given party.
/// - On success, responds with [`CreatePartyInviteOutput`](crate::output::CreatePartyInviteOutput) with field(s):
/// - [`invite(Option<CreatedInvite>)`](crate::output::CreatePartyInviteOutput::invite): Output from a created invite.
/// - On failure, responds with [`SdkError<CreatePartyInviteError>`](crate::error::CreatePartyInviteError)
pub fn create_party_invite(&self) -> fluent_builders::CreatePartyInvite<C, M, R> {
fluent_builders::CreatePartyInvite::new(self.handle.clone())
}
/// Constructs a fluent builder for the [`GetPartyFromInvite`](crate::client::fluent_builders::GetPartyFromInvite) operation.
///
/// - The fluent builder is configurable:
/// - [`token(impl Into<String>)`](crate::client::fluent_builders::GetPartyFromInvite::token) / [`set_token(Option<String>)`](crate::client::fluent_builders::GetPartyFromInvite::set_token): See `rivet.api.party#CreatedInvite$token`.
/// - [`alias(impl Into<String>)`](crate::client::fluent_builders::GetPartyFromInvite::alias) / [`set_alias(Option<String>)`](crate::client::fluent_builders::GetPartyFromInvite::set_alias): 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.
/// - On success, responds with [`GetPartyFromInviteOutput`](crate::output::GetPartyFromInviteOutput) with field(s):
/// - [`party(Option<PartySummary>)`](crate::output::GetPartyFromInviteOutput::party): A party summary.
/// - On failure, responds with [`SdkError<GetPartyFromInviteError>`](crate::error::GetPartyFromInviteError)
pub fn get_party_from_invite(&self) -> fluent_builders::GetPartyFromInvite<C, M, R> {
fluent_builders::GetPartyFromInvite::new(self.handle.clone())
}
/// Constructs a fluent builder for the [`GetPartyProfile`](crate::client::fluent_builders::GetPartyProfile) operation.
///
/// - The fluent builder is configurable:
/// - [`party_id(impl Into<String>)`](crate::client::fluent_builders::GetPartyProfile::party_id) / [`set_party_id(Option<String>)`](crate::client::fluent_builders::GetPartyProfile::set_party_id): A universally unique identifier.
/// - [`watch_index(impl Into<String>)`](crate::client::fluent_builders::GetPartyProfile::watch_index) / [`set_watch_index(Option<String>)`](crate::client::fluent_builders::GetPartyProfile::set_watch_index): A query parameter denoting the requests watch index.
/// - On success, responds with [`GetPartyProfileOutput`](crate::output::GetPartyProfileOutput) with field(s):
/// - [`party(Option<PartyProfile>)`](crate::output::GetPartyProfileOutput::party): (undocumented)
/// - [`watch(Option<WatchResponse>)`](crate::output::GetPartyProfileOutput::watch): Provided by watchable endpoints used in blocking loops.
/// - On failure, responds with [`SdkError<GetPartyProfileError>`](crate::error::GetPartyProfileError)
pub fn get_party_profile(&self) -> fluent_builders::GetPartyProfile<C, M, R> {
fluent_builders::GetPartyProfile::new(self.handle.clone())
}
/// Constructs a fluent builder for the [`GetPartySelfProfile`](crate::client::fluent_builders::GetPartySelfProfile) operation.
///
/// - The fluent builder is configurable:
/// - [`watch_index(impl Into<String>)`](crate::client::fluent_builders::GetPartySelfProfile::watch_index) / [`set_watch_index(Option<String>)`](crate::client::fluent_builders::GetPartySelfProfile::set_watch_index): A query parameter denoting the requests watch index.
/// - On success, responds with [`GetPartySelfProfileOutput`](crate::output::GetPartySelfProfileOutput) with field(s):
/// - [`party(Option<PartyProfile>)`](crate::output::GetPartySelfProfileOutput::party): (undocumented)
/// - [`watch(Option<WatchResponse>)`](crate::output::GetPartySelfProfileOutput::watch): Provided by watchable endpoints used in blocking loops.
/// - On failure, responds with [`SdkError<GetPartySelfProfileError>`](crate::error::GetPartySelfProfileError)
pub fn get_party_self_profile(&self) -> fluent_builders::GetPartySelfProfile<C, M, R> {
fluent_builders::GetPartySelfProfile::new(self.handle.clone())
}
/// Constructs a fluent builder for the [`GetPartySelfSummary`](crate::client::fluent_builders::GetPartySelfSummary) operation.
///
/// - The fluent builder is configurable:
/// - [`watch_index(impl Into<String>)`](crate::client::fluent_builders::GetPartySelfSummary::watch_index) / [`set_watch_index(Option<String>)`](crate::client::fluent_builders::GetPartySelfSummary::set_watch_index): A query parameter denoting the requests watch index.
/// - On success, responds with [`GetPartySelfSummaryOutput`](crate::output::GetPartySelfSummaryOutput) with field(s):
/// - [`party(Option<PartySummary>)`](crate::output::GetPartySelfSummaryOutput::party): A party summary.
/// - [`watch(Option<WatchResponse>)`](crate::output::GetPartySelfSummaryOutput::watch): Provided by watchable endpoints used in blocking loops.
/// - On failure, responds with [`SdkError<GetPartySelfSummaryError>`](crate::error::GetPartySelfSummaryError)
pub fn get_party_self_summary(&self) -> fluent_builders::GetPartySelfSummary<C, M, R> {
fluent_builders::GetPartySelfSummary::new(self.handle.clone())
}
/// Constructs a fluent builder for the [`GetPartySummary`](crate::client::fluent_builders::GetPartySummary) operation.
///
/// - The fluent builder is configurable:
/// - [`party_id(impl Into<String>)`](crate::client::fluent_builders::GetPartySummary::party_id) / [`set_party_id(Option<String>)`](crate::client::fluent_builders::GetPartySummary::set_party_id): A universally unique identifier.
/// - [`watch_index(impl Into<String>)`](crate::client::fluent_builders::GetPartySummary::watch_index) / [`set_watch_index(Option<String>)`](crate::client::fluent_builders::GetPartySummary::set_watch_index): A query parameter denoting the requests watch index.
/// - On success, responds with [`GetPartySummaryOutput`](crate::output::GetPartySummaryOutput) with field(s):
/// - [`party(Option<PartySummary>)`](crate::output::GetPartySummaryOutput::party): A party summary.
/// - [`watch(Option<WatchResponse>)`](crate::output::GetPartySummaryOutput::watch): Provided by watchable endpoints used in blocking loops.
/// - On failure, responds with [`SdkError<GetPartySummaryError>`](crate::error::GetPartySummaryError)
pub fn get_party_summary(&self) -> fluent_builders::GetPartySummary<C, M, R> {
fluent_builders::GetPartySummary::new(self.handle.clone())
}
/// Constructs a fluent builder for the [`JoinParty`](crate::client::fluent_builders::JoinParty) operation.
///
/// - The fluent builder is configurable:
/// - [`invite(JoinPartyInvite)`](crate::client::fluent_builders::JoinParty::invite) / [`set_invite(Option<JoinPartyInvite>)`](crate::client::fluent_builders::JoinParty::set_invite): Represents methods of joining a party.
/// - [`matchmaker_auto_join_lobby(bool)`](crate::client::fluent_builders::JoinParty::matchmaker_auto_join_lobby) / [`set_matchmaker_auto_join_lobby(Option<bool>)`](crate::client::fluent_builders::JoinParty::set_matchmaker_auto_join_lobby): Whether or not to automatically join the game lobby if a party is currently in game.
/// - On success, responds with [`JoinPartyOutput`](crate::output::JoinPartyOutput) with field(s):
/// - [`party_id(Option<String>)`](crate::output::JoinPartyOutput::party_id): A universally unique identifier.
/// - On failure, responds with [`SdkError<JoinPartyError>`](crate::error::JoinPartyError)
pub fn join_party(&self) -> fluent_builders::JoinParty<C, M, R> {
fluent_builders::JoinParty::new(self.handle.clone())
}
/// Constructs a fluent builder for the [`KickMember`](crate::client::fluent_builders::KickMember) operation.
///
/// - The fluent builder is configurable:
/// - [`identity_id(impl Into<String>)`](crate::client::fluent_builders::KickMember::identity_id) / [`set_identity_id(Option<String>)`](crate::client::fluent_builders::KickMember::set_identity_id): A universally unique identifier.
/// - On success, responds with [`KickMemberOutput`](crate::output::KickMemberOutput)
/// - On failure, responds with [`SdkError<KickMemberError>`](crate::error::KickMemberError)
pub fn kick_member(&self) -> fluent_builders::KickMember<C, M, R> {
fluent_builders::KickMember::new(self.handle.clone())
}
/// Constructs a fluent builder for the [`LeaveParty`](crate::client::fluent_builders::LeaveParty) operation.
///
/// - The fluent builder takes no input, just [`send`](crate::client::fluent_builders::LeaveParty::send) it.
/// - On success, responds with [`LeavePartyOutput`](crate::output::LeavePartyOutput)
/// - On failure, responds with [`SdkError<LeavePartyError>`](crate::error::LeavePartyError)
pub fn leave_party(&self) -> fluent_builders::LeaveParty<C, M, R> {
fluent_builders::LeaveParty::new(self.handle.clone())
}
/// Constructs a fluent builder for the [`RevokePartyInvite`](crate::client::fluent_builders::RevokePartyInvite) operation.
///
/// - The fluent builder is configurable:
/// - [`invite_id(impl Into<String>)`](crate::client::fluent_builders::RevokePartyInvite::invite_id) / [`set_invite_id(Option<String>)`](crate::client::fluent_builders::RevokePartyInvite::set_invite_id): A universally unique identifier.
/// - On success, responds with [`RevokePartyInviteOutput`](crate::output::RevokePartyInviteOutput)
/// - On failure, responds with [`SdkError<RevokePartyInviteError>`](crate::error::RevokePartyInviteError)
pub fn revoke_party_invite(&self) -> fluent_builders::RevokePartyInvite<C, M, R> {
fluent_builders::RevokePartyInvite::new(self.handle.clone())
}
/// Constructs a fluent builder for the [`SendJoinRequest`](crate::client::fluent_builders::SendJoinRequest) operation.
///
/// - The fluent builder is configurable:
/// - [`party_id(impl Into<String>)`](crate::client::fluent_builders::SendJoinRequest::party_id) / [`set_party_id(Option<String>)`](crate::client::fluent_builders::SendJoinRequest::set_party_id): A universally unique identifier.
/// - On success, responds with [`SendJoinRequestOutput`](crate::output::SendJoinRequestOutput)
/// - On failure, responds with [`SdkError<SendJoinRequestError>`](crate::error::SendJoinRequestError)
pub fn send_join_request(&self) -> fluent_builders::SendJoinRequest<C, M, R> {
fluent_builders::SendJoinRequest::new(self.handle.clone())
}
/// Constructs a fluent builder for the [`SetPartyPublicity`](crate::client::fluent_builders::SetPartyPublicity) operation.
///
/// - The fluent builder is configurable:
/// - [`public(PartyPublicityLevel)`](crate::client::fluent_builders::SetPartyPublicity::public) / [`set_public(Option<PartyPublicityLevel>)`](crate::client::fluent_builders::SetPartyPublicity::set_public): Defaults to `rivet.party#PartyPublicityLevel$VIEW`.
/// - [`mutual_followers(PartyPublicityLevel)`](crate::client::fluent_builders::SetPartyPublicity::mutual_followers) / [`set_mutual_followers(Option<PartyPublicityLevel>)`](crate::client::fluent_builders::SetPartyPublicity::set_mutual_followers): Defaults to `rivet.party#PartyPublicityLevel$JOIN`.
/// - [`groups(PartyPublicityLevel)`](crate::client::fluent_builders::SetPartyPublicity::groups) / [`set_groups(Option<PartyPublicityLevel>)`](crate::client::fluent_builders::SetPartyPublicity::set_groups): Defaults to `rivet.party#PartyPublicityLevel$VIEW`.
/// - On success, responds with [`SetPartyPublicityOutput`](crate::output::SetPartyPublicityOutput)
/// - On failure, responds with [`SdkError<SetPartyPublicityError>`](crate::error::SetPartyPublicityError)
pub fn set_party_publicity(&self) -> fluent_builders::SetPartyPublicity<C, M, R> {
fluent_builders::SetPartyPublicity::new(self.handle.clone())
}
/// Constructs a fluent builder for the [`TransferPartyOwnership`](crate::client::fluent_builders::TransferPartyOwnership) operation.
///
/// - The fluent builder is configurable:
/// - [`identity_id(impl Into<String>)`](crate::client::fluent_builders::TransferPartyOwnership::identity_id) / [`set_identity_id(Option<String>)`](crate::client::fluent_builders::TransferPartyOwnership::set_identity_id): A universally unique identifier.
/// - On success, responds with [`TransferPartyOwnershipOutput`](crate::output::TransferPartyOwnershipOutput)
/// - On failure, responds with [`SdkError<TransferPartyOwnershipError>`](crate::error::TransferPartyOwnershipError)
pub fn transfer_party_ownership(&self) -> fluent_builders::TransferPartyOwnership<C, M, R> {
fluent_builders::TransferPartyOwnership::new(self.handle.clone())
}
/// Constructs a fluent builder for the [`FindMatchmakerLobbyForParty`](crate::client::fluent_builders::FindMatchmakerLobbyForParty) operation.
///
/// - The fluent builder is configurable:
/// - [`game_modes(Vec<String>)`](crate::client::fluent_builders::FindMatchmakerLobbyForParty::game_modes) / [`set_game_modes(Option<Vec<String>>)`](crate::client::fluent_builders::FindMatchmakerLobbyForParty::set_game_modes): Game modes to match lobbies against.
/// - [`regions(Vec<String>)`](crate::client::fluent_builders::FindMatchmakerLobbyForParty::regions) / [`set_regions(Option<Vec<String>>)`](crate::client::fluent_builders::FindMatchmakerLobbyForParty::set_regions): Regions to match lobbies against. If not specified, the optimal region will be determined and will attempt to find lobbies in that region.
/// - [`prevent_auto_create_lobby(bool)`](crate::client::fluent_builders::FindMatchmakerLobbyForParty::prevent_auto_create_lobby) / [`set_prevent_auto_create_lobby(Option<bool>)`](crate::client::fluent_builders::FindMatchmakerLobbyForParty::set_prevent_auto_create_lobby): Prevents a new lobby from being created when finding a lobby. If no lobby is found, `MATCHMAKER_LOBBY_NOT_FOUND` will be returned.
/// - [`origin(impl Into<String>)`](crate::client::fluent_builders::FindMatchmakerLobbyForParty::origin) / [`set_origin(Option<String>)`](crate::client::fluent_builders::FindMatchmakerLobbyForParty::set_origin): (undocumented)
/// - On success, responds with [`FindMatchmakerLobbyForPartyOutput`](crate::output::FindMatchmakerLobbyForPartyOutput)
/// - On failure, responds with [`SdkError<FindMatchmakerLobbyForPartyError>`](crate::error::FindMatchmakerLobbyForPartyError)
pub fn find_matchmaker_lobby_for_party(
&self,
) -> fluent_builders::FindMatchmakerLobbyForParty<C, M, R> {
fluent_builders::FindMatchmakerLobbyForParty::new(self.handle.clone())
}
/// Constructs a fluent builder for the [`JoinMatchmakerLobbyForParty`](crate::client::fluent_builders::JoinMatchmakerLobbyForParty) operation.
///
/// - The fluent builder is configurable:
/// - [`lobby_id(impl Into<String>)`](crate::client::fluent_builders::JoinMatchmakerLobbyForParty::lobby_id) / [`set_lobby_id(Option<String>)`](crate::client::fluent_builders::JoinMatchmakerLobbyForParty::set_lobby_id): A universally unique identifier.
/// - On success, responds with [`JoinMatchmakerLobbyForPartyOutput`](crate::output::JoinMatchmakerLobbyForPartyOutput)
/// - On failure, responds with [`SdkError<JoinMatchmakerLobbyForPartyError>`](crate::error::JoinMatchmakerLobbyForPartyError)
pub fn join_matchmaker_lobby_for_party(
&self,
) -> fluent_builders::JoinMatchmakerLobbyForParty<C, M, R> {
fluent_builders::JoinMatchmakerLobbyForParty::new(self.handle.clone())
}
/// Constructs a fluent builder for the [`RequestMatchmakerPlayer`](crate::client::fluent_builders::RequestMatchmakerPlayer) operation.
///
/// - The fluent builder takes no input, just [`send`](crate::client::fluent_builders::RequestMatchmakerPlayer::send) it.
/// - On success, responds with [`RequestMatchmakerPlayerOutput`](crate::output::RequestMatchmakerPlayerOutput)
/// - On failure, responds with [`SdkError<RequestMatchmakerPlayerError>`](crate::error::RequestMatchmakerPlayerError)
pub fn request_matchmaker_player(&self) -> fluent_builders::RequestMatchmakerPlayer<C, M, R> {
fluent_builders::RequestMatchmakerPlayer::new(self.handle.clone())
}
/// Constructs a fluent builder for the [`SetPartyToIdle`](crate::client::fluent_builders::SetPartyToIdle) operation.
///
/// - The fluent builder takes no input, just [`send`](crate::client::fluent_builders::SetPartyToIdle::send) it.
/// - On success, responds with [`SetPartyToIdleOutput`](crate::output::SetPartyToIdleOutput)
/// - On failure, responds with [`SdkError<SetPartyToIdleError>`](crate::error::SetPartyToIdleError)
pub fn set_party_to_idle(&self) -> fluent_builders::SetPartyToIdle<C, M, R> {
fluent_builders::SetPartyToIdle::new(self.handle.clone())
}
}
pub mod fluent_builders {
//!
//! Utilities to ergonomically construct a request to the service.
//!
//! Fluent builders are created through the [`Client`](crate::client::Client) by calling
//! one if its operation methods. After parameters are set using the builder methods,
//! the `send` method can be called to initiate the request.
//!
/// Fluent builder constructing a request to `CreateParty`.
///
/// Creates a new party.
#[derive(std::clone::Clone, std::fmt::Debug)]
pub struct CreateParty<C, M, R = aws_smithy_client::retry::Standard> {
handle: std::sync::Arc<super::Handle<C, M, R>>,
inner: crate::input::create_party_input::Builder,
}
impl<C, M, R> CreateParty<C, M, R>
where
C: aws_smithy_client::bounds::SmithyConnector,
M: aws_smithy_client::bounds::SmithyMiddleware<C>,
R: aws_smithy_client::retry::NewRequestPolicy,
{
/// Creates a new `CreateParty`.
pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
Self {
handle,
inner: Default::default(),
}
}
/// Sends the request and returns the response.
///
/// If an error occurs, an `SdkError` will be returned with additional details that
/// can be matched against.
///
/// By default, any retryable failures will be retried twice. Retry behavior
/// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
/// set when configuring the client.
pub async fn send(
self,
) -> std::result::Result<
crate::output::CreatePartyOutput,
aws_smithy_http::result::SdkError<crate::error::CreatePartyError>,
>
where
R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
crate::input::CreatePartyInputOperationOutputAlias,
crate::output::CreatePartyOutput,
crate::error::CreatePartyError,
crate::input::CreatePartyInputOperationRetryAlias,
>,
{
let op = self
.inner
.build()
.map_err(|err| aws_smithy_http::result::SdkError::ConstructionFailure(err.into()))?
.make_operation(&self.handle.conf)
.await
.map_err(|err| {
aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
})?;
self.handle.client.call(op).await
}
/// How many members can join the party. If using this party with the matchmaker, this number should be less than or equal to your party player limit. Super large parties may not be able to fit insite a lobby and be unable to join the game.
pub fn party_size(mut self, input: i32) -> Self {
self.inner = self.inner.party_size(input);
self
}
/// How many members can join the party. If using this party with the matchmaker, this number should be less than or equal to your party player limit. Super large parties may not be able to fit insite a lobby and be unable to join the game.
pub fn set_party_size(mut self, input: std::option::Option<i32>) -> Self {
self.inner = self.inner.set_party_size(input);
self
}
/// Publicity configuration for creating a party. Null values will default
pub fn publicity(mut self, input: crate::model::CreatePartyPublicityConfig) -> Self {
self.inner = self.inner.publicity(input);
self
}
/// Publicity configuration for creating a party. Null values will default
pub fn set_publicity(
mut self,
input: std::option::Option<crate::model::CreatePartyPublicityConfig>,
) -> Self {
self.inner = self.inner.set_publicity(input);
self
}
/// Appends an item to `invites`.
///
/// To override the contents of this collection use [`set_invites`](Self::set_invites).
///
#[allow(missing_docs)] // documentation missing in model
pub fn invites(mut self, input: crate::model::CreatePartyInviteConfig) -> Self {
self.inner = self.inner.invites(input);
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn set_invites(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::CreatePartyInviteConfig>>,
) -> Self {
self.inner = self.inner.set_invites(input);
self
}
/// If the player is currently in the lobby, pass the token from `rivet.matchmaker#MatchmakerLobbyJoinInfoPlayer$token`. This will prevent issuing a new player token and automatically set the party state to the player's current lobby.
pub fn matchmaker_current_player_token(
mut self,
input: impl Into<std::string::String>,
) -> Self {
self.inner = self.inner.matchmaker_current_player_token(input.into());
self
}
/// If the player is currently in the lobby, pass the token from `rivet.matchmaker#MatchmakerLobbyJoinInfoPlayer$token`. This will prevent issuing a new player token and automatically set the party state to the player's current lobby.
pub fn set_matchmaker_current_player_token(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.inner = self.inner.set_matchmaker_current_player_token(input);
self
}
}
/// Fluent builder constructing a request to `CreatePartyInvite`.
///
/// Creates a new party invite for the current identity's party. Identity must be the party leader.
#[derive(std::clone::Clone, std::fmt::Debug)]
pub struct CreatePartyInvite<C, M, R = aws_smithy_client::retry::Standard> {
handle: std::sync::Arc<super::Handle<C, M, R>>,
inner: crate::input::create_party_invite_input::Builder,
}
impl<C, M, R> CreatePartyInvite<C, M, R>
where
C: aws_smithy_client::bounds::SmithyConnector,
M: aws_smithy_client::bounds::SmithyMiddleware<C>,
R: aws_smithy_client::retry::NewRequestPolicy,
{
/// Creates a new `CreatePartyInvite`.
pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
Self {
handle,
inner: Default::default(),
}
}
/// Sends the request and returns the response.
///
/// If an error occurs, an `SdkError` will be returned with additional details that
/// can be matched against.
///
/// By default, any retryable failures will be retried twice. Retry behavior
/// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
/// set when configuring the client.
pub async fn send(
self,
) -> std::result::Result<
crate::output::CreatePartyInviteOutput,
aws_smithy_http::result::SdkError<crate::error::CreatePartyInviteError>,
>
where
R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
crate::input::CreatePartyInviteInputOperationOutputAlias,
crate::output::CreatePartyInviteOutput,
crate::error::CreatePartyInviteError,
crate::input::CreatePartyInviteInputOperationRetryAlias,
>,
{
let op = self
.inner
.build()
.map_err(|err| aws_smithy_http::result::SdkError::ConstructionFailure(err.into()))?
.make_operation(&self.handle.conf)
.await
.map_err(|err| {
aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
})?;
self.handle.client.call(op).await
}
/// An alias used to join a given party.
pub fn alias(mut self, input: impl Into<std::string::String>) -> Self {
self.inner = self.inner.alias(input.into());
self
}
/// An alias used to join a given party.
pub fn set_alias(mut self, input: std::option::Option<std::string::String>) -> Self {
self.inner = self.inner.set_alias(input);
self
}
}
/// Fluent builder constructing a request to `GetPartyFromInvite`.
///
/// Fetches a party based on a given invite.
#[derive(std::clone::Clone, std::fmt::Debug)]
pub struct GetPartyFromInvite<C, M, R = aws_smithy_client::retry::Standard> {
handle: std::sync::Arc<super::Handle<C, M, R>>,
inner: crate::input::get_party_from_invite_input::Builder,
}
impl<C, M, R> GetPartyFromInvite<C, M, R>
where
C: aws_smithy_client::bounds::SmithyConnector,
M: aws_smithy_client::bounds::SmithyMiddleware<C>,
R: aws_smithy_client::retry::NewRequestPolicy,
{
/// Creates a new `GetPartyFromInvite`.
pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
Self {
handle,
inner: Default::default(),
}
}
/// Sends the request and returns the response.
///
/// If an error occurs, an `SdkError` will be returned with additional details that
/// can be matched against.
///
/// By default, any retryable failures will be retried twice. Retry behavior
/// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
/// set when configuring the client.
pub async fn send(
self,
) -> std::result::Result<
crate::output::GetPartyFromInviteOutput,
aws_smithy_http::result::SdkError<crate::error::GetPartyFromInviteError>,
>
where
R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
crate::input::GetPartyFromInviteInputOperationOutputAlias,
crate::output::GetPartyFromInviteOutput,
crate::error::GetPartyFromInviteError,
crate::input::GetPartyFromInviteInputOperationRetryAlias,
>,
{
let op = self
.inner
.build()
.map_err(|err| aws_smithy_http::result::SdkError::ConstructionFailure(err.into()))?
.make_operation(&self.handle.conf)
.await
.map_err(|err| {
aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
})?;
self.handle.client.call(op).await
}
/// See `rivet.api.party#CreatedInvite$token`.
pub fn token(mut self, input: impl Into<std::string::String>) -> Self {
self.inner = self.inner.token(input.into());
self
}
/// See `rivet.api.party#CreatedInvite$token`.
pub fn set_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.inner = self.inner.set_token(input);
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 alias(mut self, input: impl Into<std::string::String>) -> Self {
self.inner = self.inner.alias(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.inner = self.inner.set_alias(input);
self
}
}
/// Fluent builder constructing a request to `GetPartyProfile`.
///
/// Returns a party profile.
#[derive(std::clone::Clone, std::fmt::Debug)]
pub struct GetPartyProfile<C, M, R = aws_smithy_client::retry::Standard> {
handle: std::sync::Arc<super::Handle<C, M, R>>,
inner: crate::input::get_party_profile_input::Builder,
}
impl<C, M, R> GetPartyProfile<C, M, R>
where
C: aws_smithy_client::bounds::SmithyConnector,
M: aws_smithy_client::bounds::SmithyMiddleware<C>,
R: aws_smithy_client::retry::NewRequestPolicy,
{
/// Creates a new `GetPartyProfile`.
pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
Self {
handle,
inner: Default::default(),
}
}
/// Sends the request and returns the response.
///
/// If an error occurs, an `SdkError` will be returned with additional details that
/// can be matched against.
///
/// By default, any retryable failures will be retried twice. Retry behavior
/// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
/// set when configuring the client.
pub async fn send(
self,
) -> std::result::Result<
crate::output::GetPartyProfileOutput,
aws_smithy_http::result::SdkError<crate::error::GetPartyProfileError>,
>
where
R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
crate::input::GetPartyProfileInputOperationOutputAlias,
crate::output::GetPartyProfileOutput,
crate::error::GetPartyProfileError,
crate::input::GetPartyProfileInputOperationRetryAlias,
>,
{
let op = self
.inner
.build()
.map_err(|err| aws_smithy_http::result::SdkError::ConstructionFailure(err.into()))?
.make_operation(&self.handle.conf)
.await
.map_err(|err| {
aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
})?;
self.handle.client.call(op).await
}
/// A universally unique identifier.
pub fn party_id(mut self, input: impl Into<std::string::String>) -> Self {
self.inner = self.inner.party_id(input.into());
self
}
/// A universally unique identifier.
pub fn set_party_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.inner = self.inner.set_party_id(input);
self
}
/// A query parameter denoting the requests watch index.
pub fn watch_index(mut self, input: impl Into<std::string::String>) -> Self {
self.inner = self.inner.watch_index(input.into());
self
}
/// A query parameter denoting the requests watch index.
pub fn set_watch_index(mut self, input: std::option::Option<std::string::String>) -> Self {
self.inner = self.inner.set_watch_index(input);
self
}
}
/// Fluent builder constructing a request to `GetPartySelfProfile`.
///
/// Returns a party profile for the party the current identity is a member of.
#[derive(std::clone::Clone, std::fmt::Debug)]
pub struct GetPartySelfProfile<C, M, R = aws_smithy_client::retry::Standard> {
handle: std::sync::Arc<super::Handle<C, M, R>>,
inner: crate::input::get_party_self_profile_input::Builder,
}
impl<C, M, R> GetPartySelfProfile<C, M, R>
where
C: aws_smithy_client::bounds::SmithyConnector,
M: aws_smithy_client::bounds::SmithyMiddleware<C>,
R: aws_smithy_client::retry::NewRequestPolicy,
{
/// Creates a new `GetPartySelfProfile`.
pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
Self {
handle,
inner: Default::default(),
}
}
/// Sends the request and returns the response.
///
/// If an error occurs, an `SdkError` will be returned with additional details that
/// can be matched against.
///
/// By default, any retryable failures will be retried twice. Retry behavior
/// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
/// set when configuring the client.
pub async fn send(
self,
) -> std::result::Result<
crate::output::GetPartySelfProfileOutput,
aws_smithy_http::result::SdkError<crate::error::GetPartySelfProfileError>,
>
where
R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
crate::input::GetPartySelfProfileInputOperationOutputAlias,
crate::output::GetPartySelfProfileOutput,
crate::error::GetPartySelfProfileError,
crate::input::GetPartySelfProfileInputOperationRetryAlias,
>,
{
let op = self
.inner
.build()
.map_err(|err| aws_smithy_http::result::SdkError::ConstructionFailure(err.into()))?
.make_operation(&self.handle.conf)
.await
.map_err(|err| {
aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
})?;
self.handle.client.call(op).await
}
/// A query parameter denoting the requests watch index.
pub fn watch_index(mut self, input: impl Into<std::string::String>) -> Self {
self.inner = self.inner.watch_index(input.into());
self
}
/// A query parameter denoting the requests watch index.
pub fn set_watch_index(mut self, input: std::option::Option<std::string::String>) -> Self {
self.inner = self.inner.set_watch_index(input);
self
}
}
/// Fluent builder constructing a request to `GetPartySelfSummary`.
///
/// Returns a party summary for the party the current identity is a member of.
#[derive(std::clone::Clone, std::fmt::Debug)]
pub struct GetPartySelfSummary<C, M, R = aws_smithy_client::retry::Standard> {
handle: std::sync::Arc<super::Handle<C, M, R>>,
inner: crate::input::get_party_self_summary_input::Builder,
}
impl<C, M, R> GetPartySelfSummary<C, M, R>
where
C: aws_smithy_client::bounds::SmithyConnector,
M: aws_smithy_client::bounds::SmithyMiddleware<C>,
R: aws_smithy_client::retry::NewRequestPolicy,
{
/// Creates a new `GetPartySelfSummary`.
pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
Self {
handle,
inner: Default::default(),
}
}
/// Sends the request and returns the response.
///
/// If an error occurs, an `SdkError` will be returned with additional details that
/// can be matched against.
///
/// By default, any retryable failures will be retried twice. Retry behavior
/// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
/// set when configuring the client.
pub async fn send(
self,
) -> std::result::Result<
crate::output::GetPartySelfSummaryOutput,
aws_smithy_http::result::SdkError<crate::error::GetPartySelfSummaryError>,
>
where
R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
crate::input::GetPartySelfSummaryInputOperationOutputAlias,
crate::output::GetPartySelfSummaryOutput,
crate::error::GetPartySelfSummaryError,
crate::input::GetPartySelfSummaryInputOperationRetryAlias,
>,
{
let op = self
.inner
.build()
.map_err(|err| aws_smithy_http::result::SdkError::ConstructionFailure(err.into()))?
.make_operation(&self.handle.conf)
.await
.map_err(|err| {
aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
})?;
self.handle.client.call(op).await
}
/// A query parameter denoting the requests watch index.
pub fn watch_index(mut self, input: impl Into<std::string::String>) -> Self {
self.inner = self.inner.watch_index(input.into());
self
}
/// A query parameter denoting the requests watch index.
pub fn set_watch_index(mut self, input: std::option::Option<std::string::String>) -> Self {
self.inner = self.inner.set_watch_index(input);
self
}
}
/// Fluent builder constructing a request to `GetPartySummary`.
///
/// Returns a party summary.
#[derive(std::clone::Clone, std::fmt::Debug)]
pub struct GetPartySummary<C, M, R = aws_smithy_client::retry::Standard> {
handle: std::sync::Arc<super::Handle<C, M, R>>,
inner: crate::input::get_party_summary_input::Builder,
}
impl<C, M, R> GetPartySummary<C, M, R>
where
C: aws_smithy_client::bounds::SmithyConnector,
M: aws_smithy_client::bounds::SmithyMiddleware<C>,
R: aws_smithy_client::retry::NewRequestPolicy,
{
/// Creates a new `GetPartySummary`.
pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
Self {
handle,
inner: Default::default(),
}
}
/// Sends the request and returns the response.
///
/// If an error occurs, an `SdkError` will be returned with additional details that
/// can be matched against.
///
/// By default, any retryable failures will be retried twice. Retry behavior
/// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
/// set when configuring the client.
pub async fn send(
self,
) -> std::result::Result<
crate::output::GetPartySummaryOutput,
aws_smithy_http::result::SdkError<crate::error::GetPartySummaryError>,
>
where
R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
crate::input::GetPartySummaryInputOperationOutputAlias,
crate::output::GetPartySummaryOutput,
crate::error::GetPartySummaryError,
crate::input::GetPartySummaryInputOperationRetryAlias,
>,
{
let op = self
.inner
.build()
.map_err(|err| aws_smithy_http::result::SdkError::ConstructionFailure(err.into()))?
.make_operation(&self.handle.conf)
.await
.map_err(|err| {
aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
})?;
self.handle.client.call(op).await
}
/// A universally unique identifier.
pub fn party_id(mut self, input: impl Into<std::string::String>) -> Self {
self.inner = self.inner.party_id(input.into());
self
}
/// A universally unique identifier.
pub fn set_party_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.inner = self.inner.set_party_id(input);
self
}
/// A query parameter denoting the requests watch index.
pub fn watch_index(mut self, input: impl Into<std::string::String>) -> Self {
self.inner = self.inner.watch_index(input.into());
self
}
/// A query parameter denoting the requests watch index.
pub fn set_watch_index(mut self, input: std::option::Option<std::string::String>) -> Self {
self.inner = self.inner.set_watch_index(input);
self
}
}
/// Fluent builder constructing a request to `JoinParty`.
///
/// Joins a party using a given party invite.
#[derive(std::clone::Clone, std::fmt::Debug)]
pub struct JoinParty<C, M, R = aws_smithy_client::retry::Standard> {
handle: std::sync::Arc<super::Handle<C, M, R>>,
inner: crate::input::join_party_input::Builder,
}
impl<C, M, R> JoinParty<C, M, R>
where
C: aws_smithy_client::bounds::SmithyConnector,
M: aws_smithy_client::bounds::SmithyMiddleware<C>,
R: aws_smithy_client::retry::NewRequestPolicy,
{
/// Creates a new `JoinParty`.
pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
Self {
handle,
inner: Default::default(),
}
}
/// Sends the request and returns the response.
///
/// If an error occurs, an `SdkError` will be returned with additional details that
/// can be matched against.
///
/// By default, any retryable failures will be retried twice. Retry behavior
/// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
/// set when configuring the client.
pub async fn send(
self,
) -> std::result::Result<
crate::output::JoinPartyOutput,
aws_smithy_http::result::SdkError<crate::error::JoinPartyError>,
>
where
R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
crate::input::JoinPartyInputOperationOutputAlias,
crate::output::JoinPartyOutput,
crate::error::JoinPartyError,
crate::input::JoinPartyInputOperationRetryAlias,
>,
{
let op = self
.inner
.build()
.map_err(|err| aws_smithy_http::result::SdkError::ConstructionFailure(err.into()))?
.make_operation(&self.handle.conf)
.await
.map_err(|err| {
aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
})?;
self.handle.client.call(op).await
}
/// Represents methods of joining a party.
pub fn invite(mut self, input: crate::model::JoinPartyInvite) -> Self {
self.inner = self.inner.invite(input);
self
}
/// Represents methods of joining a party.
pub fn set_invite(
mut self,
input: std::option::Option<crate::model::JoinPartyInvite>,
) -> Self {
self.inner = self.inner.set_invite(input);
self
}
/// Whether or not to automatically join the game lobby if a party is currently in game.
pub fn matchmaker_auto_join_lobby(mut self, input: bool) -> Self {
self.inner = self.inner.matchmaker_auto_join_lobby(input);
self
}
/// Whether or not to automatically join the game lobby if a party is currently in game.
pub fn set_matchmaker_auto_join_lobby(mut self, input: std::option::Option<bool>) -> Self {
self.inner = self.inner.set_matchmaker_auto_join_lobby(input);
self
}
}
/// Fluent builder constructing a request to `KickMember`.
///
/// Kicks a member from the current identity's current party. Identity must be the party leader.
#[derive(std::clone::Clone, std::fmt::Debug)]
pub struct KickMember<C, M, R = aws_smithy_client::retry::Standard> {
handle: std::sync::Arc<super::Handle<C, M, R>>,
inner: crate::input::kick_member_input::Builder,
}
impl<C, M, R> KickMember<C, M, R>
where
C: aws_smithy_client::bounds::SmithyConnector,
M: aws_smithy_client::bounds::SmithyMiddleware<C>,
R: aws_smithy_client::retry::NewRequestPolicy,
{
/// Creates a new `KickMember`.
pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
Self {
handle,
inner: Default::default(),
}
}
/// Sends the request and returns the response.
///
/// If an error occurs, an `SdkError` will be returned with additional details that
/// can be matched against.
///
/// By default, any retryable failures will be retried twice. Retry behavior
/// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
/// set when configuring the client.
pub async fn send(
self,
) -> std::result::Result<
crate::output::KickMemberOutput,
aws_smithy_http::result::SdkError<crate::error::KickMemberError>,
>
where
R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
crate::input::KickMemberInputOperationOutputAlias,
crate::output::KickMemberOutput,
crate::error::KickMemberError,
crate::input::KickMemberInputOperationRetryAlias,
>,
{
let op = self
.inner
.build()
.map_err(|err| aws_smithy_http::result::SdkError::ConstructionFailure(err.into()))?
.make_operation(&self.handle.conf)
.await
.map_err(|err| {
aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
})?;
self.handle.client.call(op).await
}
/// A universally unique identifier.
pub fn identity_id(mut self, input: impl Into<std::string::String>) -> Self {
self.inner = self.inner.identity_id(input.into());
self
}
/// A universally unique identifier.
pub fn set_identity_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.inner = self.inner.set_identity_id(input);
self
}
}
/// Fluent builder constructing a request to `LeaveParty`.
///
/// Leaves the current identity's party.
#[derive(std::clone::Clone, std::fmt::Debug)]
pub struct LeaveParty<C, M, R = aws_smithy_client::retry::Standard> {
handle: std::sync::Arc<super::Handle<C, M, R>>,
inner: crate::input::leave_party_input::Builder,
}
impl<C, M, R> LeaveParty<C, M, R>
where
C: aws_smithy_client::bounds::SmithyConnector,
M: aws_smithy_client::bounds::SmithyMiddleware<C>,
R: aws_smithy_client::retry::NewRequestPolicy,
{
/// Creates a new `LeaveParty`.
pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
Self {
handle,
inner: Default::default(),
}
}
/// Sends the request and returns the response.
///
/// If an error occurs, an `SdkError` will be returned with additional details that
/// can be matched against.
///
/// By default, any retryable failures will be retried twice. Retry behavior
/// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
/// set when configuring the client.
pub async fn send(
self,
) -> std::result::Result<
crate::output::LeavePartyOutput,
aws_smithy_http::result::SdkError<crate::error::LeavePartyError>,
>
where
R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
crate::input::LeavePartyInputOperationOutputAlias,
crate::output::LeavePartyOutput,
crate::error::LeavePartyError,
crate::input::LeavePartyInputOperationRetryAlias,
>,
{
let op = self
.inner
.build()
.map_err(|err| aws_smithy_http::result::SdkError::ConstructionFailure(err.into()))?
.make_operation(&self.handle.conf)
.await
.map_err(|err| {
aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
})?;
self.handle.client.call(op).await
}
}
/// Fluent builder constructing a request to `RevokePartyInvite`.
///
/// Revokes a party invite from the current identity's party. Identity must be the party leader.
#[derive(std::clone::Clone, std::fmt::Debug)]
pub struct RevokePartyInvite<C, M, R = aws_smithy_client::retry::Standard> {
handle: std::sync::Arc<super::Handle<C, M, R>>,
inner: crate::input::revoke_party_invite_input::Builder,
}
impl<C, M, R> RevokePartyInvite<C, M, R>
where
C: aws_smithy_client::bounds::SmithyConnector,
M: aws_smithy_client::bounds::SmithyMiddleware<C>,
R: aws_smithy_client::retry::NewRequestPolicy,
{
/// Creates a new `RevokePartyInvite`.
pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
Self {
handle,
inner: Default::default(),
}
}
/// Sends the request and returns the response.
///
/// If an error occurs, an `SdkError` will be returned with additional details that
/// can be matched against.
///
/// By default, any retryable failures will be retried twice. Retry behavior
/// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
/// set when configuring the client.
pub async fn send(
self,
) -> std::result::Result<
crate::output::RevokePartyInviteOutput,
aws_smithy_http::result::SdkError<crate::error::RevokePartyInviteError>,
>
where
R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
crate::input::RevokePartyInviteInputOperationOutputAlias,
crate::output::RevokePartyInviteOutput,
crate::error::RevokePartyInviteError,
crate::input::RevokePartyInviteInputOperationRetryAlias,
>,
{
let op = self
.inner
.build()
.map_err(|err| aws_smithy_http::result::SdkError::ConstructionFailure(err.into()))?
.make_operation(&self.handle.conf)
.await
.map_err(|err| {
aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
})?;
self.handle.client.call(op).await
}
/// A universally unique identifier.
pub fn invite_id(mut self, input: impl Into<std::string::String>) -> Self {
self.inner = self.inner.invite_id(input.into());
self
}
/// A universally unique identifier.
pub fn set_invite_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.inner = self.inner.set_invite_id(input);
self
}
}
/// Fluent builder constructing a request to `SendJoinRequest`.
///
#[derive(std::clone::Clone, std::fmt::Debug)]
pub struct SendJoinRequest<C, M, R = aws_smithy_client::retry::Standard> {
handle: std::sync::Arc<super::Handle<C, M, R>>,
inner: crate::input::send_join_request_input::Builder,
}
impl<C, M, R> SendJoinRequest<C, M, R>
where
C: aws_smithy_client::bounds::SmithyConnector,
M: aws_smithy_client::bounds::SmithyMiddleware<C>,
R: aws_smithy_client::retry::NewRequestPolicy,
{
/// Creates a new `SendJoinRequest`.
pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
Self {
handle,
inner: Default::default(),
}
}
/// Sends the request and returns the response.
///
/// If an error occurs, an `SdkError` will be returned with additional details that
/// can be matched against.
///
/// By default, any retryable failures will be retried twice. Retry behavior
/// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
/// set when configuring the client.
pub async fn send(
self,
) -> std::result::Result<
crate::output::SendJoinRequestOutput,
aws_smithy_http::result::SdkError<crate::error::SendJoinRequestError>,
>
where
R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
crate::input::SendJoinRequestInputOperationOutputAlias,
crate::output::SendJoinRequestOutput,
crate::error::SendJoinRequestError,
crate::input::SendJoinRequestInputOperationRetryAlias,
>,
{
let op = self
.inner
.build()
.map_err(|err| aws_smithy_http::result::SdkError::ConstructionFailure(err.into()))?
.make_operation(&self.handle.conf)
.await
.map_err(|err| {
aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
})?;
self.handle.client.call(op).await
}
/// A universally unique identifier.
pub fn party_id(mut self, input: impl Into<std::string::String>) -> Self {
self.inner = self.inner.party_id(input.into());
self
}
/// A universally unique identifier.
pub fn set_party_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.inner = self.inner.set_party_id(input);
self
}
}
/// Fluent builder constructing a request to `SetPartyPublicity`.
///
/// Sets the publicity of a party. This configures who can view and join the party. Identity must be the party leader.
#[derive(std::clone::Clone, std::fmt::Debug)]
pub struct SetPartyPublicity<C, M, R = aws_smithy_client::retry::Standard> {
handle: std::sync::Arc<super::Handle<C, M, R>>,
inner: crate::input::set_party_publicity_input::Builder,
}
impl<C, M, R> SetPartyPublicity<C, M, R>
where
C: aws_smithy_client::bounds::SmithyConnector,
M: aws_smithy_client::bounds::SmithyMiddleware<C>,
R: aws_smithy_client::retry::NewRequestPolicy,
{
/// Creates a new `SetPartyPublicity`.
pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
Self {
handle,
inner: Default::default(),
}
}
/// Sends the request and returns the response.
///
/// If an error occurs, an `SdkError` will be returned with additional details that
/// can be matched against.
///
/// By default, any retryable failures will be retried twice. Retry behavior
/// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
/// set when configuring the client.
pub async fn send(
self,
) -> std::result::Result<
crate::output::SetPartyPublicityOutput,
aws_smithy_http::result::SdkError<crate::error::SetPartyPublicityError>,
>
where
R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
crate::input::SetPartyPublicityInputOperationOutputAlias,
crate::output::SetPartyPublicityOutput,
crate::error::SetPartyPublicityError,
crate::input::SetPartyPublicityInputOperationRetryAlias,
>,
{
let op = self
.inner
.build()
.map_err(|err| aws_smithy_http::result::SdkError::ConstructionFailure(err.into()))?
.make_operation(&self.handle.conf)
.await
.map_err(|err| {
aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
})?;
self.handle.client.call(op).await
}
/// Defaults to `rivet.party#PartyPublicityLevel$VIEW`.
pub fn public(mut self, input: crate::model::PartyPublicityLevel) -> Self {
self.inner = self.inner.public(input);
self
}
/// Defaults to `rivet.party#PartyPublicityLevel$VIEW`.
pub fn set_public(
mut self,
input: std::option::Option<crate::model::PartyPublicityLevel>,
) -> Self {
self.inner = self.inner.set_public(input);
self
}
/// Defaults to `rivet.party#PartyPublicityLevel$JOIN`.
pub fn mutual_followers(mut self, input: crate::model::PartyPublicityLevel) -> Self {
self.inner = self.inner.mutual_followers(input);
self
}
/// Defaults to `rivet.party#PartyPublicityLevel$JOIN`.
pub fn set_mutual_followers(
mut self,
input: std::option::Option<crate::model::PartyPublicityLevel>,
) -> Self {
self.inner = self.inner.set_mutual_followers(input);
self
}
/// Defaults to `rivet.party#PartyPublicityLevel$VIEW`.
pub fn groups(mut self, input: crate::model::PartyPublicityLevel) -> Self {
self.inner = self.inner.groups(input);
self
}
/// Defaults to `rivet.party#PartyPublicityLevel$VIEW`.
pub fn set_groups(
mut self,
input: std::option::Option<crate::model::PartyPublicityLevel>,
) -> Self {
self.inner = self.inner.set_groups(input);
self
}
}
/// Fluent builder constructing a request to `TransferPartyOwnership`.
///
/// Transfers ownership of the party to another party member. Identity must be the party leader.
#[derive(std::clone::Clone, std::fmt::Debug)]
pub struct TransferPartyOwnership<C, M, R = aws_smithy_client::retry::Standard> {
handle: std::sync::Arc<super::Handle<C, M, R>>,
inner: crate::input::transfer_party_ownership_input::Builder,
}
impl<C, M, R> TransferPartyOwnership<C, M, R>
where
C: aws_smithy_client::bounds::SmithyConnector,
M: aws_smithy_client::bounds::SmithyMiddleware<C>,
R: aws_smithy_client::retry::NewRequestPolicy,
{
/// Creates a new `TransferPartyOwnership`.
pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
Self {
handle,
inner: Default::default(),
}
}
/// Sends the request and returns the response.
///
/// If an error occurs, an `SdkError` will be returned with additional details that
/// can be matched against.
///
/// By default, any retryable failures will be retried twice. Retry behavior
/// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
/// set when configuring the client.
pub async fn send(
self,
) -> std::result::Result<
crate::output::TransferPartyOwnershipOutput,
aws_smithy_http::result::SdkError<crate::error::TransferPartyOwnershipError>,
>
where
R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
crate::input::TransferPartyOwnershipInputOperationOutputAlias,
crate::output::TransferPartyOwnershipOutput,
crate::error::TransferPartyOwnershipError,
crate::input::TransferPartyOwnershipInputOperationRetryAlias,
>,
{
let op = self
.inner
.build()
.map_err(|err| aws_smithy_http::result::SdkError::ConstructionFailure(err.into()))?
.make_operation(&self.handle.conf)
.await
.map_err(|err| {
aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
})?;
self.handle.client.call(op).await
}
/// A universally unique identifier.
pub fn identity_id(mut self, input: impl Into<std::string::String>) -> Self {
self.inner = self.inner.identity_id(input.into());
self
}
/// A universally unique identifier.
pub fn set_identity_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.inner = self.inner.set_identity_id(input);
self
}
}
/// Fluent builder constructing a request to `FindMatchmakerLobbyForParty`.
///
/// Attempts to make the current identity's party find a lobby based on the given criteria. If succeeds, all party members will receive a `GlobalEventMatchmakerLobbyJoin` event with all the information required to join the lobby. This request will use the party player count configured for the lobby group. See `FindLobby`.
#[derive(std::clone::Clone, std::fmt::Debug)]
pub struct FindMatchmakerLobbyForParty<C, M, R = aws_smithy_client::retry::Standard> {
handle: std::sync::Arc<super::Handle<C, M, R>>,
inner: crate::input::find_matchmaker_lobby_for_party_input::Builder,
}
impl<C, M, R> FindMatchmakerLobbyForParty<C, M, R>
where
C: aws_smithy_client::bounds::SmithyConnector,
M: aws_smithy_client::bounds::SmithyMiddleware<C>,
R: aws_smithy_client::retry::NewRequestPolicy,
{
/// Creates a new `FindMatchmakerLobbyForParty`.
pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
Self {
handle,
inner: Default::default(),
}
}
/// Sends the request and returns the response.
///
/// If an error occurs, an `SdkError` will be returned with additional details that
/// can be matched against.
///
/// By default, any retryable failures will be retried twice. Retry behavior
/// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
/// set when configuring the client.
pub async fn send(
self,
) -> std::result::Result<
crate::output::FindMatchmakerLobbyForPartyOutput,
aws_smithy_http::result::SdkError<crate::error::FindMatchmakerLobbyForPartyError>,
>
where
R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
crate::input::FindMatchmakerLobbyForPartyInputOperationOutputAlias,
crate::output::FindMatchmakerLobbyForPartyOutput,
crate::error::FindMatchmakerLobbyForPartyError,
crate::input::FindMatchmakerLobbyForPartyInputOperationRetryAlias,
>,
{
let op = self
.inner
.build()
.map_err(|err| aws_smithy_http::result::SdkError::ConstructionFailure(err.into()))?
.make_operation(&self.handle.conf)
.await
.map_err(|err| {
aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
})?;
self.handle.client.call(op).await
}
/// Appends an item to `game_modes`.
///
/// To override the contents of this collection use [`set_game_modes`](Self::set_game_modes).
///
/// Game modes to match lobbies against.
pub fn game_modes(mut self, input: impl Into<std::string::String>) -> Self {
self.inner = self.inner.game_modes(input.into());
self
}
/// Game modes to match lobbies against.
pub fn set_game_modes(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.inner = self.inner.set_game_modes(input);
self
}
/// Appends an item to `regions`.
///
/// To override the contents of this collection use [`set_regions`](Self::set_regions).
///
/// Regions to match lobbies against. If not specified, the optimal region will be determined and will attempt to find lobbies in that region.
pub fn regions(mut self, input: impl Into<std::string::String>) -> Self {
self.inner = self.inner.regions(input.into());
self
}
/// Regions to match lobbies against. If not specified, the optimal region will be determined and will attempt to find lobbies in that region.
pub fn set_regions(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.inner = self.inner.set_regions(input);
self
}
/// Prevents a new lobby from being created when finding a lobby. If no lobby is found, `MATCHMAKER_LOBBY_NOT_FOUND` will be returned.
pub fn prevent_auto_create_lobby(mut self, input: bool) -> Self {
self.inner = self.inner.prevent_auto_create_lobby(input);
self
}
/// Prevents a new lobby from being created when finding a lobby. If no lobby is found, `MATCHMAKER_LOBBY_NOT_FOUND` will be returned.
pub fn set_prevent_auto_create_lobby(mut self, input: std::option::Option<bool>) -> Self {
self.inner = self.inner.set_prevent_auto_create_lobby(input);
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn origin(mut self, input: impl Into<std::string::String>) -> Self {
self.inner = self.inner.origin(input.into());
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn set_origin(mut self, input: std::option::Option<std::string::String>) -> Self {
self.inner = self.inner.set_origin(input);
self
}
}
/// Fluent builder constructing a request to `JoinMatchmakerLobbyForParty`.
///
/// Attempts to make the current identity's party join a specific matchmaker lobby. This request will use the party player count configured for the lobby group. If succeeds, all party members will receive a `GlobalEventMatchmakerLobbyJoin` event with all the information required to join the lobby. Identity must be the party leader. See `JoinLobby`.
#[derive(std::clone::Clone, std::fmt::Debug)]
pub struct JoinMatchmakerLobbyForParty<C, M, R = aws_smithy_client::retry::Standard> {
handle: std::sync::Arc<super::Handle<C, M, R>>,
inner: crate::input::join_matchmaker_lobby_for_party_input::Builder,
}
impl<C, M, R> JoinMatchmakerLobbyForParty<C, M, R>
where
C: aws_smithy_client::bounds::SmithyConnector,
M: aws_smithy_client::bounds::SmithyMiddleware<C>,
R: aws_smithy_client::retry::NewRequestPolicy,
{
/// Creates a new `JoinMatchmakerLobbyForParty`.
pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
Self {
handle,
inner: Default::default(),
}
}
/// Sends the request and returns the response.
///
/// If an error occurs, an `SdkError` will be returned with additional details that
/// can be matched against.
///
/// By default, any retryable failures will be retried twice. Retry behavior
/// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
/// set when configuring the client.
pub async fn send(
self,
) -> std::result::Result<
crate::output::JoinMatchmakerLobbyForPartyOutput,
aws_smithy_http::result::SdkError<crate::error::JoinMatchmakerLobbyForPartyError>,
>
where
R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
crate::input::JoinMatchmakerLobbyForPartyInputOperationOutputAlias,
crate::output::JoinMatchmakerLobbyForPartyOutput,
crate::error::JoinMatchmakerLobbyForPartyError,
crate::input::JoinMatchmakerLobbyForPartyInputOperationRetryAlias,
>,
{
let op = self
.inner
.build()
.map_err(|err| aws_smithy_http::result::SdkError::ConstructionFailure(err.into()))?
.make_operation(&self.handle.conf)
.await
.map_err(|err| {
aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
})?;
self.handle.client.call(op).await
}
/// A universally unique identifier.
pub fn lobby_id(mut self, input: impl Into<std::string::String>) -> Self {
self.inner = self.inner.lobby_id(input.into());
self
}
/// A universally unique identifier.
pub fn set_lobby_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.inner = self.inner.set_lobby_id(input);
self
}
}
/// Fluent builder constructing a request to `RequestMatchmakerPlayer`.
///
/// Attempts to create a new matchmaker player for the current identity. If succeeds, the identity will receive a `GlobalEventMatchmakerLobbyJoin` event with all the information required to join the lobby. Only relevant if the party is already in a matchmaker lobby. # When To Use This Endpoint ## Joining a Party Already In a Lobby When an identity joins a party that's already in a lobby, a new matchmaker player will not automatically be created unless `JoinParty#matchmaker_auto_join_lobby` is set to `true`. ## Leaving the Game and Returning If the user leaves the game and comes back but is still in the party, then they will have to create a new matchmaker player. ## Failed to Connect to Lobby or Disconnected From Lobby If the user failed to establish a connection with the lobby or they got disconnected, their matchmaker player will be removed. Use this endpoint to create a new matchmaker player.
#[derive(std::clone::Clone, std::fmt::Debug)]
pub struct RequestMatchmakerPlayer<C, M, R = aws_smithy_client::retry::Standard> {
handle: std::sync::Arc<super::Handle<C, M, R>>,
inner: crate::input::request_matchmaker_player_input::Builder,
}
impl<C, M, R> RequestMatchmakerPlayer<C, M, R>
where
C: aws_smithy_client::bounds::SmithyConnector,
M: aws_smithy_client::bounds::SmithyMiddleware<C>,
R: aws_smithy_client::retry::NewRequestPolicy,
{
/// Creates a new `RequestMatchmakerPlayer`.
pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
Self {
handle,
inner: Default::default(),
}
}
/// Sends the request and returns the response.
///
/// If an error occurs, an `SdkError` will be returned with additional details that
/// can be matched against.
///
/// By default, any retryable failures will be retried twice. Retry behavior
/// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
/// set when configuring the client.
pub async fn send(
self,
) -> std::result::Result<
crate::output::RequestMatchmakerPlayerOutput,
aws_smithy_http::result::SdkError<crate::error::RequestMatchmakerPlayerError>,
>
where
R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
crate::input::RequestMatchmakerPlayerInputOperationOutputAlias,
crate::output::RequestMatchmakerPlayerOutput,
crate::error::RequestMatchmakerPlayerError,
crate::input::RequestMatchmakerPlayerInputOperationRetryAlias,
>,
{
let op = self
.inner
.build()
.map_err(|err| aws_smithy_http::result::SdkError::ConstructionFailure(err.into()))?
.make_operation(&self.handle.conf)
.await
.map_err(|err| {
aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
})?;
self.handle.client.call(op).await
}
}
/// Fluent builder constructing a request to `SetPartyToIdle`.
///
/// Sets the activity of the current identity's party to idle. Identity must be the party leader.
#[derive(std::clone::Clone, std::fmt::Debug)]
pub struct SetPartyToIdle<C, M, R = aws_smithy_client::retry::Standard> {
handle: std::sync::Arc<super::Handle<C, M, R>>,
inner: crate::input::set_party_to_idle_input::Builder,
}
impl<C, M, R> SetPartyToIdle<C, M, R>
where
C: aws_smithy_client::bounds::SmithyConnector,
M: aws_smithy_client::bounds::SmithyMiddleware<C>,
R: aws_smithy_client::retry::NewRequestPolicy,
{
/// Creates a new `SetPartyToIdle`.
pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
Self {
handle,
inner: Default::default(),
}
}
/// Sends the request and returns the response.
///
/// If an error occurs, an `SdkError` will be returned with additional details that
/// can be matched against.
///
/// By default, any retryable failures will be retried twice. Retry behavior
/// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
/// set when configuring the client.
pub async fn send(
self,
) -> std::result::Result<
crate::output::SetPartyToIdleOutput,
aws_smithy_http::result::SdkError<crate::error::SetPartyToIdleError>,
>
where
R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
crate::input::SetPartyToIdleInputOperationOutputAlias,
crate::output::SetPartyToIdleOutput,
crate::error::SetPartyToIdleError,
crate::input::SetPartyToIdleInputOperationRetryAlias,
>,
{
let op = self
.inner
.build()
.map_err(|err| aws_smithy_http::result::SdkError::ConstructionFailure(err.into()))?
.make_operation(&self.handle.conf)
.await
.map_err(|err| {
aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
})?;
self.handle.client.call(op).await
}
}
}
/// A wrapper around [`Client`]. Helps reduce external imports.
pub struct ClientWrapper {
pub(crate) client: Client<aws_smithy_client::erase::DynConnector, tower::layer::util::Identity>,
}
impl std::ops::Deref for ClientWrapper {
type Target = Client<aws_smithy_client::erase::DynConnector, tower::layer::util::Identity>;
fn deref(&self) -> &Self::Target {
&self.client
}
}