rivet-group 0.0.7

// 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 `GroupService`.
///
/// This client allows ergonomic access to a `GroupService`-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_group::{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 [`CompleteGroupAvatarUpload`](crate::client::fluent_builders::CompleteGroupAvatarUpload) operation.
	///
	/// - The fluent builder is configurable:
	///   - [`group_id(impl Into<String>)`](crate::client::fluent_builders::CompleteGroupAvatarUpload::group_id) / [`set_group_id(Option<String>)`](crate::client::fluent_builders::CompleteGroupAvatarUpload::set_group_id): A universally unique identifier.
	///   - [`upload_id(impl Into<String>)`](crate::client::fluent_builders::CompleteGroupAvatarUpload::upload_id) / [`set_upload_id(Option<String>)`](crate::client::fluent_builders::CompleteGroupAvatarUpload::set_upload_id): A universally unique identifier.
	/// - On success, responds with [`CompleteGroupAvatarUploadOutput`](crate::output::CompleteGroupAvatarUploadOutput)

	/// - On failure, responds with [`SdkError<CompleteGroupAvatarUploadError>`](crate::error::CompleteGroupAvatarUploadError)
	pub fn complete_group_avatar_upload(
		&self,
	) -> fluent_builders::CompleteGroupAvatarUpload<C, M, R> {
		fluent_builders::CompleteGroupAvatarUpload::new(self.handle.clone())
	}
	/// Constructs a fluent builder for the [`ConsumeGroupInvite`](crate::client::fluent_builders::ConsumeGroupInvite) operation.
	///
	/// - The fluent builder is configurable:
	///   - [`group_invite_code(impl Into<String>)`](crate::client::fluent_builders::ConsumeGroupInvite::group_invite_code) / [`set_group_invite_code(Option<String>)`](crate::client::fluent_builders::ConsumeGroupInvite::set_group_invite_code): Provided by `rivet.api.group#CreateGroupInviteOutput$code`.
	/// - On success, responds with [`ConsumeGroupInviteOutput`](crate::output::ConsumeGroupInviteOutput) with field(s):
	///   - [`group_id(Option<String>)`](crate::output::ConsumeGroupInviteOutput::group_id): A universally unique identifier.
	/// - On failure, responds with [`SdkError<ConsumeGroupInviteError>`](crate::error::ConsumeGroupInviteError)
	pub fn consume_group_invite(&self) -> fluent_builders::ConsumeGroupInvite<C, M, R> {
		fluent_builders::ConsumeGroupInvite::new(self.handle.clone())
	}
	/// Constructs a fluent builder for the [`CreateGroup`](crate::client::fluent_builders::CreateGroup) operation.
	///
	/// - The fluent builder is configurable:
	///   - [`display_name(impl Into<String>)`](crate::client::fluent_builders::CreateGroup::display_name) / [`set_display_name(Option<String>)`](crate::client::fluent_builders::CreateGroup::set_display_name): Represent a resource's readable display name.
	/// - On success, responds with [`CreateGroupOutput`](crate::output::CreateGroupOutput) with field(s):
	///   - [`group_id(Option<String>)`](crate::output::CreateGroupOutput::group_id): A universally unique identifier.
	/// - On failure, responds with [`SdkError<CreateGroupError>`](crate::error::CreateGroupError)
	pub fn create_group(&self) -> fluent_builders::CreateGroup<C, M, R> {
		fluent_builders::CreateGroup::new(self.handle.clone())
	}
	/// Constructs a fluent builder for the [`CreateGroupInvite`](crate::client::fluent_builders::CreateGroupInvite) operation.
	///
	/// - The fluent builder is configurable:
	///   - [`group_id(impl Into<String>)`](crate::client::fluent_builders::CreateGroupInvite::group_id) / [`set_group_id(Option<String>)`](crate::client::fluent_builders::CreateGroupInvite::set_group_id): A universally unique identifier.
	///   - [`ttl(i64)`](crate::client::fluent_builders::CreateGroupInvite::ttl) / [`set_ttl(Option<i64>)`](crate::client::fluent_builders::CreateGroupInvite::set_ttl): How long until the group invite expires (in milliseconds).
	///   - [`use_count(i64)`](crate::client::fluent_builders::CreateGroupInvite::use_count) / [`set_use_count(Option<i64>)`](crate::client::fluent_builders::CreateGroupInvite::set_use_count): How many times the group invite can be used.
	/// - On success, responds with [`CreateGroupInviteOutput`](crate::output::CreateGroupInviteOutput) with field(s):
	///   - [`code(Option<String>)`](crate::output::CreateGroupInviteOutput::code): The code that will be passed to `rivet.api.group#ConsumeGroupInvite` to join a group.
	/// - On failure, responds with [`SdkError<CreateGroupInviteError>`](crate::error::CreateGroupInviteError)
	pub fn create_group_invite(&self) -> fluent_builders::CreateGroupInvite<C, M, R> {
		fluent_builders::CreateGroupInvite::new(self.handle.clone())
	}
	/// Constructs a fluent builder for the [`CreateGroupJoinRequest`](crate::client::fluent_builders::CreateGroupJoinRequest) operation.
	///
	/// - The fluent builder is configurable:
	///   - [`group_id(impl Into<String>)`](crate::client::fluent_builders::CreateGroupJoinRequest::group_id) / [`set_group_id(Option<String>)`](crate::client::fluent_builders::CreateGroupJoinRequest::set_group_id): A universally unique identifier.
	/// - On success, responds with [`CreateGroupJoinRequestOutput`](crate::output::CreateGroupJoinRequestOutput)

	/// - On failure, responds with [`SdkError<CreateGroupJoinRequestError>`](crate::error::CreateGroupJoinRequestError)
	pub fn create_group_join_request(&self) -> fluent_builders::CreateGroupJoinRequest<C, M, R> {
		fluent_builders::CreateGroupJoinRequest::new(self.handle.clone())
	}
	/// Constructs a fluent builder for the [`GetGroupInvite`](crate::client::fluent_builders::GetGroupInvite) operation.
	///
	/// - The fluent builder is configurable:
	///   - [`group_invite_code(impl Into<String>)`](crate::client::fluent_builders::GetGroupInvite::group_invite_code) / [`set_group_invite_code(Option<String>)`](crate::client::fluent_builders::GetGroupInvite::set_group_invite_code): Provided by `rivet.api.group#CreateGroupInviteOutput$code`.
	/// - On success, responds with [`GetGroupInviteOutput`](crate::output::GetGroupInviteOutput) with field(s):
	///   - [`group(Option<GroupHandle>)`](crate::output::GetGroupInviteOutput::group): A group handle.
	/// - On failure, responds with [`SdkError<GetGroupInviteError>`](crate::error::GetGroupInviteError)
	pub fn get_group_invite(&self) -> fluent_builders::GetGroupInvite<C, M, R> {
		fluent_builders::GetGroupInvite::new(self.handle.clone())
	}
	/// Constructs a fluent builder for the [`GetGroupProfile`](crate::client::fluent_builders::GetGroupProfile) operation.
	///
	/// - The fluent builder is configurable:
	///   - [`group_id(impl Into<String>)`](crate::client::fluent_builders::GetGroupProfile::group_id) / [`set_group_id(Option<String>)`](crate::client::fluent_builders::GetGroupProfile::set_group_id): A universally unique identifier.
	///   - [`watch_index(impl Into<String>)`](crate::client::fluent_builders::GetGroupProfile::watch_index) / [`set_watch_index(Option<String>)`](crate::client::fluent_builders::GetGroupProfile::set_watch_index): A query parameter denoting the requests watch index.
	/// - On success, responds with [`GetGroupProfileOutput`](crate::output::GetGroupProfileOutput) with field(s):
	///   - [`group(Option<GroupProfile>)`](crate::output::GetGroupProfileOutput::group): A list of group profiles.
	///   - [`watch(Option<WatchResponse>)`](crate::output::GetGroupProfileOutput::watch): Provided by watchable endpoints used in blocking loops.
	/// - On failure, responds with [`SdkError<GetGroupProfileError>`](crate::error::GetGroupProfileError)
	pub fn get_group_profile(&self) -> fluent_builders::GetGroupProfile<C, M, R> {
		fluent_builders::GetGroupProfile::new(self.handle.clone())
	}
	/// Constructs a fluent builder for the [`GetGroupSummary`](crate::client::fluent_builders::GetGroupSummary) operation.
	///
	/// - The fluent builder is configurable:
	///   - [`group_id(impl Into<String>)`](crate::client::fluent_builders::GetGroupSummary::group_id) / [`set_group_id(Option<String>)`](crate::client::fluent_builders::GetGroupSummary::set_group_id): A universally unique identifier.
	/// - On success, responds with [`GetGroupSummaryOutput`](crate::output::GetGroupSummaryOutput) with field(s):
	///   - [`group(Option<GroupSummary>)`](crate::output::GetGroupSummaryOutput::group): A group summary.
	/// - On failure, responds with [`SdkError<GetGroupSummaryError>`](crate::error::GetGroupSummaryError)
	pub fn get_group_summary(&self) -> fluent_builders::GetGroupSummary<C, M, R> {
		fluent_builders::GetGroupSummary::new(self.handle.clone())
	}
	/// Constructs a fluent builder for the [`JoinGroup`](crate::client::fluent_builders::JoinGroup) operation.
	///
	/// - The fluent builder is configurable:
	///   - [`group_id(impl Into<String>)`](crate::client::fluent_builders::JoinGroup::group_id) / [`set_group_id(Option<String>)`](crate::client::fluent_builders::JoinGroup::set_group_id): A universally unique identifier.
	/// - On success, responds with [`JoinGroupOutput`](crate::output::JoinGroupOutput)

	/// - On failure, responds with [`SdkError<JoinGroupError>`](crate::error::JoinGroupError)
	pub fn join_group(&self) -> fluent_builders::JoinGroup<C, M, R> {
		fluent_builders::JoinGroup::new(self.handle.clone())
	}
	/// Constructs a fluent builder for the [`LeaveGroup`](crate::client::fluent_builders::LeaveGroup) operation.
	///
	/// - The fluent builder is configurable:
	///   - [`group_id(impl Into<String>)`](crate::client::fluent_builders::LeaveGroup::group_id) / [`set_group_id(Option<String>)`](crate::client::fluent_builders::LeaveGroup::set_group_id): A universally unique identifier.
	/// - On success, responds with [`LeaveGroupOutput`](crate::output::LeaveGroupOutput)

	/// - On failure, responds with [`SdkError<LeaveGroupError>`](crate::error::LeaveGroupError)
	pub fn leave_group(&self) -> fluent_builders::LeaveGroup<C, M, R> {
		fluent_builders::LeaveGroup::new(self.handle.clone())
	}
	/// Constructs a fluent builder for the [`ListSuggestedGroups`](crate::client::fluent_builders::ListSuggestedGroups) operation.
	///
	/// - The fluent builder is configurable:
	///   - [`watch_index(impl Into<String>)`](crate::client::fluent_builders::ListSuggestedGroups::watch_index) / [`set_watch_index(Option<String>)`](crate::client::fluent_builders::ListSuggestedGroups::set_watch_index): A query parameter denoting the requests watch index.
	/// - On success, responds with [`ListSuggestedGroupsOutput`](crate::output::ListSuggestedGroupsOutput) with field(s):
	///   - [`groups(Option<Vec<GroupSummary>>)`](crate::output::ListSuggestedGroupsOutput::groups): A list of group summaries.
	///   - [`watch(Option<WatchResponse>)`](crate::output::ListSuggestedGroupsOutput::watch): Provided by watchable endpoints used in blocking loops.
	/// - On failure, responds with [`SdkError<ListSuggestedGroupsError>`](crate::error::ListSuggestedGroupsError)
	pub fn list_suggested_groups(&self) -> fluent_builders::ListSuggestedGroups<C, M, R> {
		fluent_builders::ListSuggestedGroups::new(self.handle.clone())
	}
	/// Constructs a fluent builder for the [`PrepareGroupAvatarUpload`](crate::client::fluent_builders::PrepareGroupAvatarUpload) operation.
	///
	/// - The fluent builder is configurable:
	///   - [`path(impl Into<String>)`](crate::client::fluent_builders::PrepareGroupAvatarUpload::path) / [`set_path(Option<String>)`](crate::client::fluent_builders::PrepareGroupAvatarUpload::set_path): The path/filename of the group avatar.
	///   - [`mime(impl Into<String>)`](crate::client::fluent_builders::PrepareGroupAvatarUpload::mime) / [`set_mime(Option<String>)`](crate::client::fluent_builders::PrepareGroupAvatarUpload::set_mime): The MIME type of the group avatar.
	///   - [`content_length(i64)`](crate::client::fluent_builders::PrepareGroupAvatarUpload::content_length) / [`set_content_length(Option<i64>)`](crate::client::fluent_builders::PrepareGroupAvatarUpload::set_content_length): Unsigned 64 bit integer.
	/// - On success, responds with [`PrepareGroupAvatarUploadOutput`](crate::output::PrepareGroupAvatarUploadOutput) with field(s):
	///   - [`upload_id(Option<String>)`](crate::output::PrepareGroupAvatarUploadOutput::upload_id): A universally unique identifier.
	///   - [`presigned_request(Option<UploadPresignedRequest>)`](crate::output::PrepareGroupAvatarUploadOutput::presigned_request): A presigned request used to upload files. Upload your file to the given URL via a PUT request.
	/// - On failure, responds with [`SdkError<PrepareGroupAvatarUploadError>`](crate::error::PrepareGroupAvatarUploadError)
	pub fn prepare_group_avatar_upload(
		&self,
	) -> fluent_builders::PrepareGroupAvatarUpload<C, M, R> {
		fluent_builders::PrepareGroupAvatarUpload::new(self.handle.clone())
	}
	/// Constructs a fluent builder for the [`ResolveGroupJoinRequest`](crate::client::fluent_builders::ResolveGroupJoinRequest) operation.
	///
	/// - The fluent builder is configurable:
	///   - [`group_id(impl Into<String>)`](crate::client::fluent_builders::ResolveGroupJoinRequest::group_id) / [`set_group_id(Option<String>)`](crate::client::fluent_builders::ResolveGroupJoinRequest::set_group_id): A universally unique identifier.
	///   - [`identity_id(impl Into<String>)`](crate::client::fluent_builders::ResolveGroupJoinRequest::identity_id) / [`set_identity_id(Option<String>)`](crate::client::fluent_builders::ResolveGroupJoinRequest::set_identity_id): A universally unique identifier.
	///   - [`resolution(bool)`](crate::client::fluent_builders::ResolveGroupJoinRequest::resolution) / [`set_resolution(Option<bool>)`](crate::client::fluent_builders::ResolveGroupJoinRequest::set_resolution): (undocumented)
	/// - On success, responds with [`ResolveGroupJoinRequestOutput`](crate::output::ResolveGroupJoinRequestOutput)

	/// - On failure, responds with [`SdkError<ResolveGroupJoinRequestError>`](crate::error::ResolveGroupJoinRequestError)
	pub fn resolve_group_join_request(&self) -> fluent_builders::ResolveGroupJoinRequest<C, M, R> {
		fluent_builders::ResolveGroupJoinRequest::new(self.handle.clone())
	}
	/// Constructs a fluent builder for the [`SearchGroups`](crate::client::fluent_builders::SearchGroups) operation.
	///
	/// - The fluent builder is configurable:
	///   - [`query(impl Into<String>)`](crate::client::fluent_builders::SearchGroups::query) / [`set_query(Option<String>)`](crate::client::fluent_builders::SearchGroups::set_query): The query to match group display names against.
	///   - [`anchor(impl Into<String>)`](crate::client::fluent_builders::SearchGroups::anchor) / [`set_anchor(Option<String>)`](crate::client::fluent_builders::SearchGroups::set_anchor): How many groups to offset the search by.
	///   - [`limit(i32)`](crate::client::fluent_builders::SearchGroups::limit) / [`set_limit(Option<i32>)`](crate::client::fluent_builders::SearchGroups::set_limit): Amount of groups to return.
	/// - On success, responds with [`SearchGroupsOutput`](crate::output::SearchGroupsOutput) with field(s):
	///   - [`groups(Option<Vec<GroupHandle>>)`](crate::output::SearchGroupsOutput::groups): A list of group handles.
	/// - On failure, responds with [`SdkError<SearchGroupsError>`](crate::error::SearchGroupsError)
	pub fn search_groups(&self) -> fluent_builders::SearchGroups<C, M, R> {
		fluent_builders::SearchGroups::new(self.handle.clone())
	}
	/// Constructs a fluent builder for the [`TransferGroupOwnership`](crate::client::fluent_builders::TransferGroupOwnership) operation.
	///
	/// - The fluent builder is configurable:
	///   - [`group_id(impl Into<String>)`](crate::client::fluent_builders::TransferGroupOwnership::group_id) / [`set_group_id(Option<String>)`](crate::client::fluent_builders::TransferGroupOwnership::set_group_id): A universally unique identifier.
	///   - [`new_owner_identity_id(impl Into<String>)`](crate::client::fluent_builders::TransferGroupOwnership::new_owner_identity_id) / [`set_new_owner_identity_id(Option<String>)`](crate::client::fluent_builders::TransferGroupOwnership::set_new_owner_identity_id): Idnetity to transfer the group to. Must be a member of the group.
	/// - On success, responds with [`TransferGroupOwnershipOutput`](crate::output::TransferGroupOwnershipOutput)

	/// - On failure, responds with [`SdkError<TransferGroupOwnershipError>`](crate::error::TransferGroupOwnershipError)
	pub fn transfer_group_ownership(&self) -> fluent_builders::TransferGroupOwnership<C, M, R> {
		fluent_builders::TransferGroupOwnership::new(self.handle.clone())
	}
	/// Constructs a fluent builder for the [`UpdateGroupProfile`](crate::client::fluent_builders::UpdateGroupProfile) operation.
	///
	/// - The fluent builder is configurable:
	///   - [`group_id(impl Into<String>)`](crate::client::fluent_builders::UpdateGroupProfile::group_id) / [`set_group_id(Option<String>)`](crate::client::fluent_builders::UpdateGroupProfile::set_group_id): A universally unique identifier.
	///   - [`display_name(impl Into<String>)`](crate::client::fluent_builders::UpdateGroupProfile::display_name) / [`set_display_name(Option<String>)`](crate::client::fluent_builders::UpdateGroupProfile::set_display_name): Represent a resource's readable display name.
	///   - [`bio(impl Into<String>)`](crate::client::fluent_builders::UpdateGroupProfile::bio) / [`set_bio(Option<String>)`](crate::client::fluent_builders::UpdateGroupProfile::set_bio): Detailed information about a profile.
	///   - [`publicity(GroupPublicity)`](crate::client::fluent_builders::UpdateGroupProfile::publicity) / [`set_publicity(Option<GroupPublicity>)`](crate::client::fluent_builders::UpdateGroupProfile::set_publicity): The current publicity value for the given group.
	/// - On success, responds with [`UpdateGroupProfileOutput`](crate::output::UpdateGroupProfileOutput)

	/// - On failure, responds with [`SdkError<UpdateGroupProfileError>`](crate::error::UpdateGroupProfileError)
	pub fn update_group_profile(&self) -> fluent_builders::UpdateGroupProfile<C, M, R> {
		fluent_builders::UpdateGroupProfile::new(self.handle.clone())
	}
	/// Constructs a fluent builder for the [`ValidateGroupProfile`](crate::client::fluent_builders::ValidateGroupProfile) operation.
	///
	/// - The fluent builder is configurable:
	///   - [`display_name(impl Into<String>)`](crate::client::fluent_builders::ValidateGroupProfile::display_name) / [`set_display_name(Option<String>)`](crate::client::fluent_builders::ValidateGroupProfile::set_display_name): Represent a resource's readable display name.
	///   - [`bio(impl Into<String>)`](crate::client::fluent_builders::ValidateGroupProfile::bio) / [`set_bio(Option<String>)`](crate::client::fluent_builders::ValidateGroupProfile::set_bio): Detailed information about a profile.
	///   - [`publicity(GroupPublicity)`](crate::client::fluent_builders::ValidateGroupProfile::publicity) / [`set_publicity(Option<GroupPublicity>)`](crate::client::fluent_builders::ValidateGroupProfile::set_publicity): The current publicity value for the given group.
	/// - On success, responds with [`ValidateGroupProfileOutput`](crate::output::ValidateGroupProfileOutput) with field(s):
	///   - [`errors(Option<Vec<ValidationError>>)`](crate::output::ValidateGroupProfileOutput::errors): A list of validation errors.
	/// - On failure, responds with [`SdkError<ValidateGroupProfileError>`](crate::error::ValidateGroupProfileError)
	pub fn validate_group_profile(&self) -> fluent_builders::ValidateGroupProfile<C, M, R> {
		fluent_builders::ValidateGroupProfile::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 `CompleteGroupAvatarUpload`.
	///
	/// Completes an avatar image upload. Must be called after the file upload process completes. Call `rivet.api.group#PrepareGroupAvatarUpload` first.
	#[derive(std::clone::Clone, std::fmt::Debug)]
	pub struct CompleteGroupAvatarUpload<C, M, R = aws_smithy_client::retry::Standard> {
		handle: std::sync::Arc<super::Handle<C, M, R>>,
		inner: crate::input::complete_group_avatar_upload_input::Builder,
	}
	impl<C, M, R> CompleteGroupAvatarUpload<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 `CompleteGroupAvatarUpload`.
		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::CompleteGroupAvatarUploadOutput,
			aws_smithy_http::result::SdkError<crate::error::CompleteGroupAvatarUploadError>,
		>
		where
			R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
				crate::input::CompleteGroupAvatarUploadInputOperationOutputAlias,
				crate::output::CompleteGroupAvatarUploadOutput,
				crate::error::CompleteGroupAvatarUploadError,
				crate::input::CompleteGroupAvatarUploadInputOperationRetryAlias,
			>,
		{
			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 group_id(mut self, input: impl Into<std::string::String>) -> Self {
			self.inner = self.inner.group_id(input.into());
			self
		}
		/// A universally unique identifier.
		pub fn set_group_id(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.inner = self.inner.set_group_id(input);
			self
		}
		/// A universally unique identifier.
		pub fn upload_id(mut self, input: impl Into<std::string::String>) -> Self {
			self.inner = self.inner.upload_id(input.into());
			self
		}
		/// A universally unique identifier.
		pub fn set_upload_id(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.inner = self.inner.set_upload_id(input);
			self
		}
	}
	/// Fluent builder constructing a request to `ConsumeGroupInvite`.
	///
	/// Consumes a group invite to join a group.
	#[derive(std::clone::Clone, std::fmt::Debug)]
	pub struct ConsumeGroupInvite<C, M, R = aws_smithy_client::retry::Standard> {
		handle: std::sync::Arc<super::Handle<C, M, R>>,
		inner: crate::input::consume_group_invite_input::Builder,
	}
	impl<C, M, R> ConsumeGroupInvite<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 `ConsumeGroupInvite`.
		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::ConsumeGroupInviteOutput,
			aws_smithy_http::result::SdkError<crate::error::ConsumeGroupInviteError>,
		>
		where
			R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
				crate::input::ConsumeGroupInviteInputOperationOutputAlias,
				crate::output::ConsumeGroupInviteOutput,
				crate::error::ConsumeGroupInviteError,
				crate::input::ConsumeGroupInviteInputOperationRetryAlias,
			>,
		{
			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
		}
		/// Provided by `rivet.api.group#CreateGroupInviteOutput$code`.
		pub fn group_invite_code(mut self, input: impl Into<std::string::String>) -> Self {
			self.inner = self.inner.group_invite_code(input.into());
			self
		}
		/// Provided by `rivet.api.group#CreateGroupInviteOutput$code`.
		pub fn set_group_invite_code(
			mut self,
			input: std::option::Option<std::string::String>,
		) -> Self {
			self.inner = self.inner.set_group_invite_code(input);
			self
		}
	}
	/// Fluent builder constructing a request to `CreateGroup`.
	///
	/// Creates a new group.
	#[derive(std::clone::Clone, std::fmt::Debug)]
	pub struct CreateGroup<C, M, R = aws_smithy_client::retry::Standard> {
		handle: std::sync::Arc<super::Handle<C, M, R>>,
		inner: crate::input::create_group_input::Builder,
	}
	impl<C, M, R> CreateGroup<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 `CreateGroup`.
		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::CreateGroupOutput,
			aws_smithy_http::result::SdkError<crate::error::CreateGroupError>,
		>
		where
			R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
				crate::input::CreateGroupInputOperationOutputAlias,
				crate::output::CreateGroupOutput,
				crate::error::CreateGroupError,
				crate::input::CreateGroupInputOperationRetryAlias,
			>,
		{
			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
		}
		/// Represent a resource's readable display name.
		pub fn display_name(mut self, input: impl Into<std::string::String>) -> Self {
			self.inner = self.inner.display_name(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.inner = self.inner.set_display_name(input);
			self
		}
	}
	/// Fluent builder constructing a request to `CreateGroupInvite`.
	///
	/// Creates a group invite. Can be shared with other identities to let them join this group.
	#[derive(std::clone::Clone, std::fmt::Debug)]
	pub struct CreateGroupInvite<C, M, R = aws_smithy_client::retry::Standard> {
		handle: std::sync::Arc<super::Handle<C, M, R>>,
		inner: crate::input::create_group_invite_input::Builder,
	}
	impl<C, M, R> CreateGroupInvite<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 `CreateGroupInvite`.
		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::CreateGroupInviteOutput,
			aws_smithy_http::result::SdkError<crate::error::CreateGroupInviteError>,
		>
		where
			R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
				crate::input::CreateGroupInviteInputOperationOutputAlias,
				crate::output::CreateGroupInviteOutput,
				crate::error::CreateGroupInviteError,
				crate::input::CreateGroupInviteInputOperationRetryAlias,
			>,
		{
			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 group_id(mut self, input: impl Into<std::string::String>) -> Self {
			self.inner = self.inner.group_id(input.into());
			self
		}
		/// A universally unique identifier.
		pub fn set_group_id(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.inner = self.inner.set_group_id(input);
			self
		}
		/// How long until the group invite expires (in milliseconds).
		pub fn ttl(mut self, input: i64) -> Self {
			self.inner = self.inner.ttl(input);
			self
		}
		/// How long until the group invite expires (in milliseconds).
		pub fn set_ttl(mut self, input: std::option::Option<i64>) -> Self {
			self.inner = self.inner.set_ttl(input);
			self
		}
		/// How many times the group invite can be used.
		pub fn use_count(mut self, input: i64) -> Self {
			self.inner = self.inner.use_count(input);
			self
		}
		/// How many times the group invite can be used.
		pub fn set_use_count(mut self, input: std::option::Option<i64>) -> Self {
			self.inner = self.inner.set_use_count(input);
			self
		}
	}
	/// Fluent builder constructing a request to `CreateGroupJoinRequest`.
	///
	/// Requests to join a group.
	#[derive(std::clone::Clone, std::fmt::Debug)]
	pub struct CreateGroupJoinRequest<C, M, R = aws_smithy_client::retry::Standard> {
		handle: std::sync::Arc<super::Handle<C, M, R>>,
		inner: crate::input::create_group_join_request_input::Builder,
	}
	impl<C, M, R> CreateGroupJoinRequest<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 `CreateGroupJoinRequest`.
		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::CreateGroupJoinRequestOutput,
			aws_smithy_http::result::SdkError<crate::error::CreateGroupJoinRequestError>,
		>
		where
			R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
				crate::input::CreateGroupJoinRequestInputOperationOutputAlias,
				crate::output::CreateGroupJoinRequestOutput,
				crate::error::CreateGroupJoinRequestError,
				crate::input::CreateGroupJoinRequestInputOperationRetryAlias,
			>,
		{
			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 group_id(mut self, input: impl Into<std::string::String>) -> Self {
			self.inner = self.inner.group_id(input.into());
			self
		}
		/// A universally unique identifier.
		pub fn set_group_id(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.inner = self.inner.set_group_id(input);
			self
		}
	}
	/// Fluent builder constructing a request to `GetGroupInvite`.
	///
	/// Inspects a group invite returning information about the team that created it.
	#[derive(std::clone::Clone, std::fmt::Debug)]
	pub struct GetGroupInvite<C, M, R = aws_smithy_client::retry::Standard> {
		handle: std::sync::Arc<super::Handle<C, M, R>>,
		inner: crate::input::get_group_invite_input::Builder,
	}
	impl<C, M, R> GetGroupInvite<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 `GetGroupInvite`.
		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::GetGroupInviteOutput,
			aws_smithy_http::result::SdkError<crate::error::GetGroupInviteError>,
		>
		where
			R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
				crate::input::GetGroupInviteInputOperationOutputAlias,
				crate::output::GetGroupInviteOutput,
				crate::error::GetGroupInviteError,
				crate::input::GetGroupInviteInputOperationRetryAlias,
			>,
		{
			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
		}
		/// Provided by `rivet.api.group#CreateGroupInviteOutput$code`.
		pub fn group_invite_code(mut self, input: impl Into<std::string::String>) -> Self {
			self.inner = self.inner.group_invite_code(input.into());
			self
		}
		/// Provided by `rivet.api.group#CreateGroupInviteOutput$code`.
		pub fn set_group_invite_code(
			mut self,
			input: std::option::Option<std::string::String>,
		) -> Self {
			self.inner = self.inner.set_group_invite_code(input);
			self
		}
	}
	/// Fluent builder constructing a request to `GetGroupProfile`.
	///
	/// Returns a group profile.
	#[derive(std::clone::Clone, std::fmt::Debug)]
	pub struct GetGroupProfile<C, M, R = aws_smithy_client::retry::Standard> {
		handle: std::sync::Arc<super::Handle<C, M, R>>,
		inner: crate::input::get_group_profile_input::Builder,
	}
	impl<C, M, R> GetGroupProfile<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 `GetGroupProfile`.
		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::GetGroupProfileOutput,
			aws_smithy_http::result::SdkError<crate::error::GetGroupProfileError>,
		>
		where
			R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
				crate::input::GetGroupProfileInputOperationOutputAlias,
				crate::output::GetGroupProfileOutput,
				crate::error::GetGroupProfileError,
				crate::input::GetGroupProfileInputOperationRetryAlias,
			>,
		{
			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 group_id(mut self, input: impl Into<std::string::String>) -> Self {
			self.inner = self.inner.group_id(input.into());
			self
		}
		/// A universally unique identifier.
		pub fn set_group_id(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.inner = self.inner.set_group_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 `GetGroupSummary`.
	///
	#[derive(std::clone::Clone, std::fmt::Debug)]
	pub struct GetGroupSummary<C, M, R = aws_smithy_client::retry::Standard> {
		handle: std::sync::Arc<super::Handle<C, M, R>>,
		inner: crate::input::get_group_summary_input::Builder,
	}
	impl<C, M, R> GetGroupSummary<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 `GetGroupSummary`.
		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::GetGroupSummaryOutput,
			aws_smithy_http::result::SdkError<crate::error::GetGroupSummaryError>,
		>
		where
			R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
				crate::input::GetGroupSummaryInputOperationOutputAlias,
				crate::output::GetGroupSummaryOutput,
				crate::error::GetGroupSummaryError,
				crate::input::GetGroupSummaryInputOperationRetryAlias,
			>,
		{
			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 group_id(mut self, input: impl Into<std::string::String>) -> Self {
			self.inner = self.inner.group_id(input.into());
			self
		}
		/// A universally unique identifier.
		pub fn set_group_id(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.inner = self.inner.set_group_id(input);
			self
		}
	}
	/// Fluent builder constructing a request to `JoinGroup`.
	///
	#[derive(std::clone::Clone, std::fmt::Debug)]
	pub struct JoinGroup<C, M, R = aws_smithy_client::retry::Standard> {
		handle: std::sync::Arc<super::Handle<C, M, R>>,
		inner: crate::input::join_group_input::Builder,
	}
	impl<C, M, R> JoinGroup<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 `JoinGroup`.
		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::JoinGroupOutput,
			aws_smithy_http::result::SdkError<crate::error::JoinGroupError>,
		>
		where
			R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
				crate::input::JoinGroupInputOperationOutputAlias,
				crate::output::JoinGroupOutput,
				crate::error::JoinGroupError,
				crate::input::JoinGroupInputOperationRetryAlias,
			>,
		{
			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 group_id(mut self, input: impl Into<std::string::String>) -> Self {
			self.inner = self.inner.group_id(input.into());
			self
		}
		/// A universally unique identifier.
		pub fn set_group_id(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.inner = self.inner.set_group_id(input);
			self
		}
	}
	/// Fluent builder constructing a request to `LeaveGroup`.
	///
	/// Leaves a group.
	#[derive(std::clone::Clone, std::fmt::Debug)]
	pub struct LeaveGroup<C, M, R = aws_smithy_client::retry::Standard> {
		handle: std::sync::Arc<super::Handle<C, M, R>>,
		inner: crate::input::leave_group_input::Builder,
	}
	impl<C, M, R> LeaveGroup<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 `LeaveGroup`.
		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::LeaveGroupOutput,
			aws_smithy_http::result::SdkError<crate::error::LeaveGroupError>,
		>
		where
			R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
				crate::input::LeaveGroupInputOperationOutputAlias,
				crate::output::LeaveGroupOutput,
				crate::error::LeaveGroupError,
				crate::input::LeaveGroupInputOperationRetryAlias,
			>,
		{
			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 group_id(mut self, input: impl Into<std::string::String>) -> Self {
			self.inner = self.inner.group_id(input.into());
			self
		}
		/// A universally unique identifier.
		pub fn set_group_id(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.inner = self.inner.set_group_id(input);
			self
		}
	}
	/// Fluent builder constructing a request to `ListSuggestedGroups`.
	///
	/// Returns a list of suggested groups.
	#[derive(std::clone::Clone, std::fmt::Debug)]
	pub struct ListSuggestedGroups<C, M, R = aws_smithy_client::retry::Standard> {
		handle: std::sync::Arc<super::Handle<C, M, R>>,
		inner: crate::input::list_suggested_groups_input::Builder,
	}
	impl<C, M, R> ListSuggestedGroups<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 `ListSuggestedGroups`.
		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::ListSuggestedGroupsOutput,
			aws_smithy_http::result::SdkError<crate::error::ListSuggestedGroupsError>,
		>
		where
			R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
				crate::input::ListSuggestedGroupsInputOperationOutputAlias,
				crate::output::ListSuggestedGroupsOutput,
				crate::error::ListSuggestedGroupsError,
				crate::input::ListSuggestedGroupsInputOperationRetryAlias,
			>,
		{
			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 `PrepareGroupAvatarUpload`.
	///
	/// Prepares an avatar image upload. Complete upload with `rivet.api.group#CompleteGroupAvatarUpload`.
	#[derive(std::clone::Clone, std::fmt::Debug)]
	pub struct PrepareGroupAvatarUpload<C, M, R = aws_smithy_client::retry::Standard> {
		handle: std::sync::Arc<super::Handle<C, M, R>>,
		inner: crate::input::prepare_group_avatar_upload_input::Builder,
	}
	impl<C, M, R> PrepareGroupAvatarUpload<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 `PrepareGroupAvatarUpload`.
		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::PrepareGroupAvatarUploadOutput,
			aws_smithy_http::result::SdkError<crate::error::PrepareGroupAvatarUploadError>,
		>
		where
			R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
				crate::input::PrepareGroupAvatarUploadInputOperationOutputAlias,
				crate::output::PrepareGroupAvatarUploadOutput,
				crate::error::PrepareGroupAvatarUploadError,
				crate::input::PrepareGroupAvatarUploadInputOperationRetryAlias,
			>,
		{
			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
		}
		/// The path/filename of the group avatar.
		pub fn path(mut self, input: impl Into<std::string::String>) -> Self {
			self.inner = self.inner.path(input.into());
			self
		}
		/// The path/filename of the group avatar.
		pub fn set_path(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.inner = self.inner.set_path(input);
			self
		}
		/// The MIME type of the group avatar.
		pub fn mime(mut self, input: impl Into<std::string::String>) -> Self {
			self.inner = self.inner.mime(input.into());
			self
		}
		/// The MIME type of the group avatar.
		pub fn set_mime(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.inner = self.inner.set_mime(input);
			self
		}
		/// Unsigned 64 bit integer.
		pub fn content_length(mut self, input: i64) -> Self {
			self.inner = self.inner.content_length(input);
			self
		}
		/// Unsigned 64 bit integer.
		pub fn set_content_length(mut self, input: std::option::Option<i64>) -> Self {
			self.inner = self.inner.set_content_length(input);
			self
		}
	}
	/// Fluent builder constructing a request to `ResolveGroupJoinRequest`.
	///
	/// Resolves a join request for a given group.
	#[derive(std::clone::Clone, std::fmt::Debug)]
	pub struct ResolveGroupJoinRequest<C, M, R = aws_smithy_client::retry::Standard> {
		handle: std::sync::Arc<super::Handle<C, M, R>>,
		inner: crate::input::resolve_group_join_request_input::Builder,
	}
	impl<C, M, R> ResolveGroupJoinRequest<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 `ResolveGroupJoinRequest`.
		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::ResolveGroupJoinRequestOutput,
			aws_smithy_http::result::SdkError<crate::error::ResolveGroupJoinRequestError>,
		>
		where
			R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
				crate::input::ResolveGroupJoinRequestInputOperationOutputAlias,
				crate::output::ResolveGroupJoinRequestOutput,
				crate::error::ResolveGroupJoinRequestError,
				crate::input::ResolveGroupJoinRequestInputOperationRetryAlias,
			>,
		{
			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 group_id(mut self, input: impl Into<std::string::String>) -> Self {
			self.inner = self.inner.group_id(input.into());
			self
		}
		/// A universally unique identifier.
		pub fn set_group_id(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.inner = self.inner.set_group_id(input);
			self
		}
		/// 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
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn resolution(mut self, input: bool) -> Self {
			self.inner = self.inner.resolution(input);
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn set_resolution(mut self, input: std::option::Option<bool>) -> Self {
			self.inner = self.inner.set_resolution(input);
			self
		}
	}
	/// Fluent builder constructing a request to `SearchGroups`.
	///
	/// Fuzzy search for groups.
	#[derive(std::clone::Clone, std::fmt::Debug)]
	pub struct SearchGroups<C, M, R = aws_smithy_client::retry::Standard> {
		handle: std::sync::Arc<super::Handle<C, M, R>>,
		inner: crate::input::search_groups_input::Builder,
	}
	impl<C, M, R> SearchGroups<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 `SearchGroups`.
		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::SearchGroupsOutput,
			aws_smithy_http::result::SdkError<crate::error::SearchGroupsError>,
		>
		where
			R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
				crate::input::SearchGroupsInputOperationOutputAlias,
				crate::output::SearchGroupsOutput,
				crate::error::SearchGroupsError,
				crate::input::SearchGroupsInputOperationRetryAlias,
			>,
		{
			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
		}
		/// The query to match group display names against.
		pub fn query(mut self, input: impl Into<std::string::String>) -> Self {
			self.inner = self.inner.query(input.into());
			self
		}
		/// The query to match group display names against.
		pub fn set_query(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.inner = self.inner.set_query(input);
			self
		}
		/// How many groups to offset the search by.
		pub fn anchor(mut self, input: impl Into<std::string::String>) -> Self {
			self.inner = self.inner.anchor(input.into());
			self
		}
		/// How many groups to offset the search by.
		pub fn set_anchor(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.inner = self.inner.set_anchor(input);
			self
		}
		/// Amount of groups to return.
		pub fn limit(mut self, input: i32) -> Self {
			self.inner = self.inner.limit(input);
			self
		}
		/// Amount of groups to return.
		pub fn set_limit(mut self, input: std::option::Option<i32>) -> Self {
			self.inner = self.inner.set_limit(input);
			self
		}
	}
	/// Fluent builder constructing a request to `TransferGroupOwnership`.
	///
	/// Transfers ownership of a group to another identity.
	#[derive(std::clone::Clone, std::fmt::Debug)]
	pub struct TransferGroupOwnership<C, M, R = aws_smithy_client::retry::Standard> {
		handle: std::sync::Arc<super::Handle<C, M, R>>,
		inner: crate::input::transfer_group_ownership_input::Builder,
	}
	impl<C, M, R> TransferGroupOwnership<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 `TransferGroupOwnership`.
		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::TransferGroupOwnershipOutput,
			aws_smithy_http::result::SdkError<crate::error::TransferGroupOwnershipError>,
		>
		where
			R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
				crate::input::TransferGroupOwnershipInputOperationOutputAlias,
				crate::output::TransferGroupOwnershipOutput,
				crate::error::TransferGroupOwnershipError,
				crate::input::TransferGroupOwnershipInputOperationRetryAlias,
			>,
		{
			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 group_id(mut self, input: impl Into<std::string::String>) -> Self {
			self.inner = self.inner.group_id(input.into());
			self
		}
		/// A universally unique identifier.
		pub fn set_group_id(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.inner = self.inner.set_group_id(input);
			self
		}
		/// Idnetity to transfer the group to. Must be a member of the group.
		pub fn new_owner_identity_id(mut self, input: impl Into<std::string::String>) -> Self {
			self.inner = self.inner.new_owner_identity_id(input.into());
			self
		}
		/// Idnetity to transfer the group to. Must be a member of the group.
		pub fn set_new_owner_identity_id(
			mut self,
			input: std::option::Option<std::string::String>,
		) -> Self {
			self.inner = self.inner.set_new_owner_identity_id(input);
			self
		}
	}
	/// Fluent builder constructing a request to `UpdateGroupProfile`.
	///
	#[derive(std::clone::Clone, std::fmt::Debug)]
	pub struct UpdateGroupProfile<C, M, R = aws_smithy_client::retry::Standard> {
		handle: std::sync::Arc<super::Handle<C, M, R>>,
		inner: crate::input::update_group_profile_input::Builder,
	}
	impl<C, M, R> UpdateGroupProfile<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 `UpdateGroupProfile`.
		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::UpdateGroupProfileOutput,
			aws_smithy_http::result::SdkError<crate::error::UpdateGroupProfileError>,
		>
		where
			R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
				crate::input::UpdateGroupProfileInputOperationOutputAlias,
				crate::output::UpdateGroupProfileOutput,
				crate::error::UpdateGroupProfileError,
				crate::input::UpdateGroupProfileInputOperationRetryAlias,
			>,
		{
			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 group_id(mut self, input: impl Into<std::string::String>) -> Self {
			self.inner = self.inner.group_id(input.into());
			self
		}
		/// A universally unique identifier.
		pub fn set_group_id(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.inner = self.inner.set_group_id(input);
			self
		}
		/// Represent a resource's readable display name.
		pub fn display_name(mut self, input: impl Into<std::string::String>) -> Self {
			self.inner = self.inner.display_name(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.inner = self.inner.set_display_name(input);
			self
		}
		/// Detailed information about a profile.
		pub fn bio(mut self, input: impl Into<std::string::String>) -> Self {
			self.inner = self.inner.bio(input.into());
			self
		}
		/// Detailed information about a profile.
		pub fn set_bio(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.inner = self.inner.set_bio(input);
			self
		}
		/// The current publicity value for the given group.
		pub fn publicity(mut self, input: crate::model::GroupPublicity) -> Self {
			self.inner = self.inner.publicity(input);
			self
		}
		/// The current publicity value for the given group.
		pub fn set_publicity(
			mut self,
			input: std::option::Option<crate::model::GroupPublicity>,
		) -> Self {
			self.inner = self.inner.set_publicity(input);
			self
		}
	}
	/// Fluent builder constructing a request to `ValidateGroupProfile`.
	///
	/// Validate contents of group profile. Use to provide immediate feedback on profile changes before committing them.
	#[derive(std::clone::Clone, std::fmt::Debug)]
	pub struct ValidateGroupProfile<C, M, R = aws_smithy_client::retry::Standard> {
		handle: std::sync::Arc<super::Handle<C, M, R>>,
		inner: crate::input::validate_group_profile_input::Builder,
	}
	impl<C, M, R> ValidateGroupProfile<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 `ValidateGroupProfile`.
		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::ValidateGroupProfileOutput,
			aws_smithy_http::result::SdkError<crate::error::ValidateGroupProfileError>,
		>
		where
			R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
				crate::input::ValidateGroupProfileInputOperationOutputAlias,
				crate::output::ValidateGroupProfileOutput,
				crate::error::ValidateGroupProfileError,
				crate::input::ValidateGroupProfileInputOperationRetryAlias,
			>,
		{
			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
		}
		/// Represent a resource's readable display name.
		pub fn display_name(mut self, input: impl Into<std::string::String>) -> Self {
			self.inner = self.inner.display_name(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.inner = self.inner.set_display_name(input);
			self
		}
		/// Detailed information about a profile.
		pub fn bio(mut self, input: impl Into<std::string::String>) -> Self {
			self.inner = self.inner.bio(input.into());
			self
		}
		/// Detailed information about a profile.
		pub fn set_bio(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.inner = self.inner.set_bio(input);
			self
		}
		/// The current publicity value for the given group.
		pub fn publicity(mut self, input: crate::model::GroupPublicity) -> Self {
			self.inner = self.inner.publicity(input);
			self
		}
		/// The current publicity value for the given group.
		pub fn set_publicity(
			mut self,
			input: std::option::Option<crate::model::GroupPublicity>,
		) -> Self {
			self.inner = self.inner.set_publicity(input);
			self
		}
	}
}
/// 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
	}
}