rivet_party/

error.rs

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
/// Error type for the `CreateParty` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct CreatePartyError {
	/// Kind of error that occurred.
	pub kind: CreatePartyErrorKind,
	/// Additional metadata about the error, including error code, message, and request ID.
	pub(crate) meta: aws_smithy_types::Error,
}
/// Types of errors that can occur for the `CreateParty` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum CreatePartyErrorKind {
	/// An error caused by internal server problems.
	InternalError(crate::error::InternalError),
	/// An error thrown when the requestee has hit a rate limit. You are sending too many requests too quickly.
	RateLimitError(crate::error::RateLimitError),
	/// An error thrown when the requestee requests a resource they do not have access to.
	ForbiddenError(crate::error::ForbiddenError),
	/// An error thrown when the requestee is not authenticated.
	UnauthorizedError(crate::error::UnauthorizedError),
	/// An error thrown when the requestee requests a non existant resource.
	NotFoundError(crate::error::NotFoundError),
	/// An error thrown when the requestee has sent an invalid or malformed request.
	BadRequestError(crate::error::BadRequestError),
	/// An unexpected error, e.g. invalid JSON returned by the service or an unknown error code
	Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for CreatePartyError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		match &self.kind {
			CreatePartyErrorKind::InternalError(_inner) => _inner.fmt(f),
			CreatePartyErrorKind::RateLimitError(_inner) => _inner.fmt(f),
			CreatePartyErrorKind::ForbiddenError(_inner) => _inner.fmt(f),
			CreatePartyErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
			CreatePartyErrorKind::NotFoundError(_inner) => _inner.fmt(f),
			CreatePartyErrorKind::BadRequestError(_inner) => _inner.fmt(f),
			CreatePartyErrorKind::Unhandled(_inner) => _inner.fmt(f),
		}
	}
}
impl aws_smithy_types::retry::ProvideErrorKind for CreatePartyError {
	fn code(&self) -> Option<&str> {
		CreatePartyError::code(self)
	}
	fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
		match &self.kind {
			CreatePartyErrorKind::InternalError(inner) => Some(inner.retryable_error_kind()),
			CreatePartyErrorKind::UnauthorizedError(inner) => Some(inner.retryable_error_kind()),
			_ => None,
		}
	}
}
impl CreatePartyError {
	/// Creates a new `CreatePartyError`.
	pub fn new(kind: CreatePartyErrorKind, meta: aws_smithy_types::Error) -> Self {
		Self { kind, meta }
	}

	/// Creates the `CreatePartyError::Unhandled` variant from any error type.
	pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
		Self {
			kind: CreatePartyErrorKind::Unhandled(err.into()),
			meta: Default::default(),
		}
	}

	/// Creates the `CreatePartyError::Unhandled` variant from a `aws_smithy_types::Error`.
	pub fn generic(err: aws_smithy_types::Error) -> Self {
		Self {
			meta: err.clone(),
			kind: CreatePartyErrorKind::Unhandled(err.into()),
		}
	}

	/// Returns the error message if one is available.
	pub fn message(&self) -> Option<&str> {
		self.meta.message()
	}

	/// Returns error metadata, which includes the error code, message,
	/// request ID, and potentially additional information.
	pub fn meta(&self) -> &aws_smithy_types::Error {
		&self.meta
	}

	/// Returns the request ID if it's available.
	pub fn request_id(&self) -> Option<&str> {
		self.meta.request_id()
	}

	/// Returns the error code if it's available.
	pub fn code(&self) -> Option<&str> {
		self.meta.code()
	}
	/// Returns `true` if the error kind is `CreatePartyErrorKind::InternalError`.
	pub fn is_internal_error(&self) -> bool {
		matches!(&self.kind, CreatePartyErrorKind::InternalError(_))
	}
	/// Returns `true` if the error kind is `CreatePartyErrorKind::RateLimitError`.
	pub fn is_rate_limit_error(&self) -> bool {
		matches!(&self.kind, CreatePartyErrorKind::RateLimitError(_))
	}
	/// Returns `true` if the error kind is `CreatePartyErrorKind::ForbiddenError`.
	pub fn is_forbidden_error(&self) -> bool {
		matches!(&self.kind, CreatePartyErrorKind::ForbiddenError(_))
	}
	/// Returns `true` if the error kind is `CreatePartyErrorKind::UnauthorizedError`.
	pub fn is_unauthorized_error(&self) -> bool {
		matches!(&self.kind, CreatePartyErrorKind::UnauthorizedError(_))
	}
	/// Returns `true` if the error kind is `CreatePartyErrorKind::NotFoundError`.
	pub fn is_not_found_error(&self) -> bool {
		matches!(&self.kind, CreatePartyErrorKind::NotFoundError(_))
	}
	/// Returns `true` if the error kind is `CreatePartyErrorKind::BadRequestError`.
	pub fn is_bad_request_error(&self) -> bool {
		matches!(&self.kind, CreatePartyErrorKind::BadRequestError(_))
	}
}
impl std::error::Error for CreatePartyError {
	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
		match &self.kind {
			CreatePartyErrorKind::InternalError(_inner) => Some(_inner),
			CreatePartyErrorKind::RateLimitError(_inner) => Some(_inner),
			CreatePartyErrorKind::ForbiddenError(_inner) => Some(_inner),
			CreatePartyErrorKind::UnauthorizedError(_inner) => Some(_inner),
			CreatePartyErrorKind::NotFoundError(_inner) => Some(_inner),
			CreatePartyErrorKind::BadRequestError(_inner) => Some(_inner),
			CreatePartyErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
		}
	}
}

/// Error type for the `CreatePartyInvite` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct CreatePartyInviteError {
	/// Kind of error that occurred.
	pub kind: CreatePartyInviteErrorKind,
	/// Additional metadata about the error, including error code, message, and request ID.
	pub(crate) meta: aws_smithy_types::Error,
}
/// Types of errors that can occur for the `CreatePartyInvite` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum CreatePartyInviteErrorKind {
	/// An error caused by internal server problems.
	InternalError(crate::error::InternalError),
	/// An error thrown when the requestee has hit a rate limit. You are sending too many requests too quickly.
	RateLimitError(crate::error::RateLimitError),
	/// An error thrown when the requestee requests a resource they do not have access to.
	ForbiddenError(crate::error::ForbiddenError),
	/// An error thrown when the requestee is not authenticated.
	UnauthorizedError(crate::error::UnauthorizedError),
	/// An error thrown when the requestee requests a non existant resource.
	NotFoundError(crate::error::NotFoundError),
	/// An error thrown when the requestee has sent an invalid or malformed request.
	BadRequestError(crate::error::BadRequestError),
	/// An unexpected error, e.g. invalid JSON returned by the service or an unknown error code
	Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for CreatePartyInviteError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		match &self.kind {
			CreatePartyInviteErrorKind::InternalError(_inner) => _inner.fmt(f),
			CreatePartyInviteErrorKind::RateLimitError(_inner) => _inner.fmt(f),
			CreatePartyInviteErrorKind::ForbiddenError(_inner) => _inner.fmt(f),
			CreatePartyInviteErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
			CreatePartyInviteErrorKind::NotFoundError(_inner) => _inner.fmt(f),
			CreatePartyInviteErrorKind::BadRequestError(_inner) => _inner.fmt(f),
			CreatePartyInviteErrorKind::Unhandled(_inner) => _inner.fmt(f),
		}
	}
}
impl aws_smithy_types::retry::ProvideErrorKind for CreatePartyInviteError {
	fn code(&self) -> Option<&str> {
		CreatePartyInviteError::code(self)
	}
	fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
		match &self.kind {
			CreatePartyInviteErrorKind::InternalError(inner) => Some(inner.retryable_error_kind()),
			CreatePartyInviteErrorKind::UnauthorizedError(inner) => {
				Some(inner.retryable_error_kind())
			}
			_ => None,
		}
	}
}
impl CreatePartyInviteError {
	/// Creates a new `CreatePartyInviteError`.
	pub fn new(kind: CreatePartyInviteErrorKind, meta: aws_smithy_types::Error) -> Self {
		Self { kind, meta }
	}

	/// Creates the `CreatePartyInviteError::Unhandled` variant from any error type.
	pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
		Self {
			kind: CreatePartyInviteErrorKind::Unhandled(err.into()),
			meta: Default::default(),
		}
	}

	/// Creates the `CreatePartyInviteError::Unhandled` variant from a `aws_smithy_types::Error`.
	pub fn generic(err: aws_smithy_types::Error) -> Self {
		Self {
			meta: err.clone(),
			kind: CreatePartyInviteErrorKind::Unhandled(err.into()),
		}
	}

	/// Returns the error message if one is available.
	pub fn message(&self) -> Option<&str> {
		self.meta.message()
	}

	/// Returns error metadata, which includes the error code, message,
	/// request ID, and potentially additional information.
	pub fn meta(&self) -> &aws_smithy_types::Error {
		&self.meta
	}

	/// Returns the request ID if it's available.
	pub fn request_id(&self) -> Option<&str> {
		self.meta.request_id()
	}

	/// Returns the error code if it's available.
	pub fn code(&self) -> Option<&str> {
		self.meta.code()
	}
	/// Returns `true` if the error kind is `CreatePartyInviteErrorKind::InternalError`.
	pub fn is_internal_error(&self) -> bool {
		matches!(&self.kind, CreatePartyInviteErrorKind::InternalError(_))
	}
	/// Returns `true` if the error kind is `CreatePartyInviteErrorKind::RateLimitError`.
	pub fn is_rate_limit_error(&self) -> bool {
		matches!(&self.kind, CreatePartyInviteErrorKind::RateLimitError(_))
	}
	/// Returns `true` if the error kind is `CreatePartyInviteErrorKind::ForbiddenError`.
	pub fn is_forbidden_error(&self) -> bool {
		matches!(&self.kind, CreatePartyInviteErrorKind::ForbiddenError(_))
	}
	/// Returns `true` if the error kind is `CreatePartyInviteErrorKind::UnauthorizedError`.
	pub fn is_unauthorized_error(&self) -> bool {
		matches!(&self.kind, CreatePartyInviteErrorKind::UnauthorizedError(_))
	}
	/// Returns `true` if the error kind is `CreatePartyInviteErrorKind::NotFoundError`.
	pub fn is_not_found_error(&self) -> bool {
		matches!(&self.kind, CreatePartyInviteErrorKind::NotFoundError(_))
	}
	/// Returns `true` if the error kind is `CreatePartyInviteErrorKind::BadRequestError`.
	pub fn is_bad_request_error(&self) -> bool {
		matches!(&self.kind, CreatePartyInviteErrorKind::BadRequestError(_))
	}
}
impl std::error::Error for CreatePartyInviteError {
	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
		match &self.kind {
			CreatePartyInviteErrorKind::InternalError(_inner) => Some(_inner),
			CreatePartyInviteErrorKind::RateLimitError(_inner) => Some(_inner),
			CreatePartyInviteErrorKind::ForbiddenError(_inner) => Some(_inner),
			CreatePartyInviteErrorKind::UnauthorizedError(_inner) => Some(_inner),
			CreatePartyInviteErrorKind::NotFoundError(_inner) => Some(_inner),
			CreatePartyInviteErrorKind::BadRequestError(_inner) => Some(_inner),
			CreatePartyInviteErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
		}
	}
}

/// Error type for the `GetPartyFromInvite` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct GetPartyFromInviteError {
	/// Kind of error that occurred.
	pub kind: GetPartyFromInviteErrorKind,
	/// Additional metadata about the error, including error code, message, and request ID.
	pub(crate) meta: aws_smithy_types::Error,
}
/// Types of errors that can occur for the `GetPartyFromInvite` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum GetPartyFromInviteErrorKind {
	/// An error caused by internal server problems.
	InternalError(crate::error::InternalError),
	/// An error thrown when the requestee has hit a rate limit. You are sending too many requests too quickly.
	RateLimitError(crate::error::RateLimitError),
	/// An error thrown when the requestee requests a resource they do not have access to.
	ForbiddenError(crate::error::ForbiddenError),
	/// An error thrown when the requestee is not authenticated.
	UnauthorizedError(crate::error::UnauthorizedError),
	/// An error thrown when the requestee requests a non existant resource.
	NotFoundError(crate::error::NotFoundError),
	/// An error thrown when the requestee has sent an invalid or malformed request.
	BadRequestError(crate::error::BadRequestError),
	/// An unexpected error, e.g. invalid JSON returned by the service or an unknown error code
	Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for GetPartyFromInviteError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		match &self.kind {
			GetPartyFromInviteErrorKind::InternalError(_inner) => _inner.fmt(f),
			GetPartyFromInviteErrorKind::RateLimitError(_inner) => _inner.fmt(f),
			GetPartyFromInviteErrorKind::ForbiddenError(_inner) => _inner.fmt(f),
			GetPartyFromInviteErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
			GetPartyFromInviteErrorKind::NotFoundError(_inner) => _inner.fmt(f),
			GetPartyFromInviteErrorKind::BadRequestError(_inner) => _inner.fmt(f),
			GetPartyFromInviteErrorKind::Unhandled(_inner) => _inner.fmt(f),
		}
	}
}
impl aws_smithy_types::retry::ProvideErrorKind for GetPartyFromInviteError {
	fn code(&self) -> Option<&str> {
		GetPartyFromInviteError::code(self)
	}
	fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
		match &self.kind {
			GetPartyFromInviteErrorKind::InternalError(inner) => Some(inner.retryable_error_kind()),
			GetPartyFromInviteErrorKind::UnauthorizedError(inner) => {
				Some(inner.retryable_error_kind())
			}
			_ => None,
		}
	}
}
impl GetPartyFromInviteError {
	/// Creates a new `GetPartyFromInviteError`.
	pub fn new(kind: GetPartyFromInviteErrorKind, meta: aws_smithy_types::Error) -> Self {
		Self { kind, meta }
	}

	/// Creates the `GetPartyFromInviteError::Unhandled` variant from any error type.
	pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
		Self {
			kind: GetPartyFromInviteErrorKind::Unhandled(err.into()),
			meta: Default::default(),
		}
	}

	/// Creates the `GetPartyFromInviteError::Unhandled` variant from a `aws_smithy_types::Error`.
	pub fn generic(err: aws_smithy_types::Error) -> Self {
		Self {
			meta: err.clone(),
			kind: GetPartyFromInviteErrorKind::Unhandled(err.into()),
		}
	}

	/// Returns the error message if one is available.
	pub fn message(&self) -> Option<&str> {
		self.meta.message()
	}

	/// Returns error metadata, which includes the error code, message,
	/// request ID, and potentially additional information.
	pub fn meta(&self) -> &aws_smithy_types::Error {
		&self.meta
	}

	/// Returns the request ID if it's available.
	pub fn request_id(&self) -> Option<&str> {
		self.meta.request_id()
	}

	/// Returns the error code if it's available.
	pub fn code(&self) -> Option<&str> {
		self.meta.code()
	}
	/// Returns `true` if the error kind is `GetPartyFromInviteErrorKind::InternalError`.
	pub fn is_internal_error(&self) -> bool {
		matches!(&self.kind, GetPartyFromInviteErrorKind::InternalError(_))
	}
	/// Returns `true` if the error kind is `GetPartyFromInviteErrorKind::RateLimitError`.
	pub fn is_rate_limit_error(&self) -> bool {
		matches!(&self.kind, GetPartyFromInviteErrorKind::RateLimitError(_))
	}
	/// Returns `true` if the error kind is `GetPartyFromInviteErrorKind::ForbiddenError`.
	pub fn is_forbidden_error(&self) -> bool {
		matches!(&self.kind, GetPartyFromInviteErrorKind::ForbiddenError(_))
	}
	/// Returns `true` if the error kind is `GetPartyFromInviteErrorKind::UnauthorizedError`.
	pub fn is_unauthorized_error(&self) -> bool {
		matches!(
			&self.kind,
			GetPartyFromInviteErrorKind::UnauthorizedError(_)
		)
	}
	/// Returns `true` if the error kind is `GetPartyFromInviteErrorKind::NotFoundError`.
	pub fn is_not_found_error(&self) -> bool {
		matches!(&self.kind, GetPartyFromInviteErrorKind::NotFoundError(_))
	}
	/// Returns `true` if the error kind is `GetPartyFromInviteErrorKind::BadRequestError`.
	pub fn is_bad_request_error(&self) -> bool {
		matches!(&self.kind, GetPartyFromInviteErrorKind::BadRequestError(_))
	}
}
impl std::error::Error for GetPartyFromInviteError {
	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
		match &self.kind {
			GetPartyFromInviteErrorKind::InternalError(_inner) => Some(_inner),
			GetPartyFromInviteErrorKind::RateLimitError(_inner) => Some(_inner),
			GetPartyFromInviteErrorKind::ForbiddenError(_inner) => Some(_inner),
			GetPartyFromInviteErrorKind::UnauthorizedError(_inner) => Some(_inner),
			GetPartyFromInviteErrorKind::NotFoundError(_inner) => Some(_inner),
			GetPartyFromInviteErrorKind::BadRequestError(_inner) => Some(_inner),
			GetPartyFromInviteErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
		}
	}
}

/// Error type for the `GetPartyProfile` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct GetPartyProfileError {
	/// Kind of error that occurred.
	pub kind: GetPartyProfileErrorKind,
	/// Additional metadata about the error, including error code, message, and request ID.
	pub(crate) meta: aws_smithy_types::Error,
}
/// Types of errors that can occur for the `GetPartyProfile` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum GetPartyProfileErrorKind {
	/// An error caused by internal server problems.
	InternalError(crate::error::InternalError),
	/// An error thrown when the requestee has hit a rate limit. You are sending too many requests too quickly.
	RateLimitError(crate::error::RateLimitError),
	/// An error thrown when the requestee requests a resource they do not have access to.
	ForbiddenError(crate::error::ForbiddenError),
	/// An error thrown when the requestee is not authenticated.
	UnauthorizedError(crate::error::UnauthorizedError),
	/// An error thrown when the requestee requests a non existant resource.
	NotFoundError(crate::error::NotFoundError),
	/// An error thrown when the requestee has sent an invalid or malformed request.
	BadRequestError(crate::error::BadRequestError),
	/// An unexpected error, e.g. invalid JSON returned by the service or an unknown error code
	Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for GetPartyProfileError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		match &self.kind {
			GetPartyProfileErrorKind::InternalError(_inner) => _inner.fmt(f),
			GetPartyProfileErrorKind::RateLimitError(_inner) => _inner.fmt(f),
			GetPartyProfileErrorKind::ForbiddenError(_inner) => _inner.fmt(f),
			GetPartyProfileErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
			GetPartyProfileErrorKind::NotFoundError(_inner) => _inner.fmt(f),
			GetPartyProfileErrorKind::BadRequestError(_inner) => _inner.fmt(f),
			GetPartyProfileErrorKind::Unhandled(_inner) => _inner.fmt(f),
		}
	}
}
impl aws_smithy_types::retry::ProvideErrorKind for GetPartyProfileError {
	fn code(&self) -> Option<&str> {
		GetPartyProfileError::code(self)
	}
	fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
		match &self.kind {
			GetPartyProfileErrorKind::InternalError(inner) => Some(inner.retryable_error_kind()),
			GetPartyProfileErrorKind::UnauthorizedError(inner) => {
				Some(inner.retryable_error_kind())
			}
			_ => None,
		}
	}
}
impl GetPartyProfileError {
	/// Creates a new `GetPartyProfileError`.
	pub fn new(kind: GetPartyProfileErrorKind, meta: aws_smithy_types::Error) -> Self {
		Self { kind, meta }
	}

	/// Creates the `GetPartyProfileError::Unhandled` variant from any error type.
	pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
		Self {
			kind: GetPartyProfileErrorKind::Unhandled(err.into()),
			meta: Default::default(),
		}
	}

	/// Creates the `GetPartyProfileError::Unhandled` variant from a `aws_smithy_types::Error`.
	pub fn generic(err: aws_smithy_types::Error) -> Self {
		Self {
			meta: err.clone(),
			kind: GetPartyProfileErrorKind::Unhandled(err.into()),
		}
	}

	/// Returns the error message if one is available.
	pub fn message(&self) -> Option<&str> {
		self.meta.message()
	}

	/// Returns error metadata, which includes the error code, message,
	/// request ID, and potentially additional information.
	pub fn meta(&self) -> &aws_smithy_types::Error {
		&self.meta
	}

	/// Returns the request ID if it's available.
	pub fn request_id(&self) -> Option<&str> {
		self.meta.request_id()
	}

	/// Returns the error code if it's available.
	pub fn code(&self) -> Option<&str> {
		self.meta.code()
	}
	/// Returns `true` if the error kind is `GetPartyProfileErrorKind::InternalError`.
	pub fn is_internal_error(&self) -> bool {
		matches!(&self.kind, GetPartyProfileErrorKind::InternalError(_))
	}
	/// Returns `true` if the error kind is `GetPartyProfileErrorKind::RateLimitError`.
	pub fn is_rate_limit_error(&self) -> bool {
		matches!(&self.kind, GetPartyProfileErrorKind::RateLimitError(_))
	}
	/// Returns `true` if the error kind is `GetPartyProfileErrorKind::ForbiddenError`.
	pub fn is_forbidden_error(&self) -> bool {
		matches!(&self.kind, GetPartyProfileErrorKind::ForbiddenError(_))
	}
	/// Returns `true` if the error kind is `GetPartyProfileErrorKind::UnauthorizedError`.
	pub fn is_unauthorized_error(&self) -> bool {
		matches!(&self.kind, GetPartyProfileErrorKind::UnauthorizedError(_))
	}
	/// Returns `true` if the error kind is `GetPartyProfileErrorKind::NotFoundError`.
	pub fn is_not_found_error(&self) -> bool {
		matches!(&self.kind, GetPartyProfileErrorKind::NotFoundError(_))
	}
	/// Returns `true` if the error kind is `GetPartyProfileErrorKind::BadRequestError`.
	pub fn is_bad_request_error(&self) -> bool {
		matches!(&self.kind, GetPartyProfileErrorKind::BadRequestError(_))
	}
}
impl std::error::Error for GetPartyProfileError {
	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
		match &self.kind {
			GetPartyProfileErrorKind::InternalError(_inner) => Some(_inner),
			GetPartyProfileErrorKind::RateLimitError(_inner) => Some(_inner),
			GetPartyProfileErrorKind::ForbiddenError(_inner) => Some(_inner),
			GetPartyProfileErrorKind::UnauthorizedError(_inner) => Some(_inner),
			GetPartyProfileErrorKind::NotFoundError(_inner) => Some(_inner),
			GetPartyProfileErrorKind::BadRequestError(_inner) => Some(_inner),
			GetPartyProfileErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
		}
	}
}

/// Error type for the `GetPartySelfProfile` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct GetPartySelfProfileError {
	/// Kind of error that occurred.
	pub kind: GetPartySelfProfileErrorKind,
	/// Additional metadata about the error, including error code, message, and request ID.
	pub(crate) meta: aws_smithy_types::Error,
}
/// Types of errors that can occur for the `GetPartySelfProfile` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum GetPartySelfProfileErrorKind {
	/// An error caused by internal server problems.
	InternalError(crate::error::InternalError),
	/// An error thrown when the requestee has hit a rate limit. You are sending too many requests too quickly.
	RateLimitError(crate::error::RateLimitError),
	/// An error thrown when the requestee requests a resource they do not have access to.
	ForbiddenError(crate::error::ForbiddenError),
	/// An error thrown when the requestee is not authenticated.
	UnauthorizedError(crate::error::UnauthorizedError),
	/// An error thrown when the requestee requests a non existant resource.
	NotFoundError(crate::error::NotFoundError),
	/// An error thrown when the requestee has sent an invalid or malformed request.
	BadRequestError(crate::error::BadRequestError),
	/// An unexpected error, e.g. invalid JSON returned by the service or an unknown error code
	Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for GetPartySelfProfileError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		match &self.kind {
			GetPartySelfProfileErrorKind::InternalError(_inner) => _inner.fmt(f),
			GetPartySelfProfileErrorKind::RateLimitError(_inner) => _inner.fmt(f),
			GetPartySelfProfileErrorKind::ForbiddenError(_inner) => _inner.fmt(f),
			GetPartySelfProfileErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
			GetPartySelfProfileErrorKind::NotFoundError(_inner) => _inner.fmt(f),
			GetPartySelfProfileErrorKind::BadRequestError(_inner) => _inner.fmt(f),
			GetPartySelfProfileErrorKind::Unhandled(_inner) => _inner.fmt(f),
		}
	}
}
impl aws_smithy_types::retry::ProvideErrorKind for GetPartySelfProfileError {
	fn code(&self) -> Option<&str> {
		GetPartySelfProfileError::code(self)
	}
	fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
		match &self.kind {
			GetPartySelfProfileErrorKind::InternalError(inner) => {
				Some(inner.retryable_error_kind())
			}
			GetPartySelfProfileErrorKind::UnauthorizedError(inner) => {
				Some(inner.retryable_error_kind())
			}
			_ => None,
		}
	}
}
impl GetPartySelfProfileError {
	/// Creates a new `GetPartySelfProfileError`.
	pub fn new(kind: GetPartySelfProfileErrorKind, meta: aws_smithy_types::Error) -> Self {
		Self { kind, meta }
	}

	/// Creates the `GetPartySelfProfileError::Unhandled` variant from any error type.
	pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
		Self {
			kind: GetPartySelfProfileErrorKind::Unhandled(err.into()),
			meta: Default::default(),
		}
	}

	/// Creates the `GetPartySelfProfileError::Unhandled` variant from a `aws_smithy_types::Error`.
	pub fn generic(err: aws_smithy_types::Error) -> Self {
		Self {
			meta: err.clone(),
			kind: GetPartySelfProfileErrorKind::Unhandled(err.into()),
		}
	}

	/// Returns the error message if one is available.
	pub fn message(&self) -> Option<&str> {
		self.meta.message()
	}

	/// Returns error metadata, which includes the error code, message,
	/// request ID, and potentially additional information.
	pub fn meta(&self) -> &aws_smithy_types::Error {
		&self.meta
	}

	/// Returns the request ID if it's available.
	pub fn request_id(&self) -> Option<&str> {
		self.meta.request_id()
	}

	/// Returns the error code if it's available.
	pub fn code(&self) -> Option<&str> {
		self.meta.code()
	}
	/// Returns `true` if the error kind is `GetPartySelfProfileErrorKind::InternalError`.
	pub fn is_internal_error(&self) -> bool {
		matches!(&self.kind, GetPartySelfProfileErrorKind::InternalError(_))
	}
	/// Returns `true` if the error kind is `GetPartySelfProfileErrorKind::RateLimitError`.
	pub fn is_rate_limit_error(&self) -> bool {
		matches!(&self.kind, GetPartySelfProfileErrorKind::RateLimitError(_))
	}
	/// Returns `true` if the error kind is `GetPartySelfProfileErrorKind::ForbiddenError`.
	pub fn is_forbidden_error(&self) -> bool {
		matches!(&self.kind, GetPartySelfProfileErrorKind::ForbiddenError(_))
	}
	/// Returns `true` if the error kind is `GetPartySelfProfileErrorKind::UnauthorizedError`.
	pub fn is_unauthorized_error(&self) -> bool {
		matches!(
			&self.kind,
			GetPartySelfProfileErrorKind::UnauthorizedError(_)
		)
	}
	/// Returns `true` if the error kind is `GetPartySelfProfileErrorKind::NotFoundError`.
	pub fn is_not_found_error(&self) -> bool {
		matches!(&self.kind, GetPartySelfProfileErrorKind::NotFoundError(_))
	}
	/// Returns `true` if the error kind is `GetPartySelfProfileErrorKind::BadRequestError`.
	pub fn is_bad_request_error(&self) -> bool {
		matches!(&self.kind, GetPartySelfProfileErrorKind::BadRequestError(_))
	}
}
impl std::error::Error for GetPartySelfProfileError {
	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
		match &self.kind {
			GetPartySelfProfileErrorKind::InternalError(_inner) => Some(_inner),
			GetPartySelfProfileErrorKind::RateLimitError(_inner) => Some(_inner),
			GetPartySelfProfileErrorKind::ForbiddenError(_inner) => Some(_inner),
			GetPartySelfProfileErrorKind::UnauthorizedError(_inner) => Some(_inner),
			GetPartySelfProfileErrorKind::NotFoundError(_inner) => Some(_inner),
			GetPartySelfProfileErrorKind::BadRequestError(_inner) => Some(_inner),
			GetPartySelfProfileErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
		}
	}
}

/// Error type for the `GetPartySelfSummary` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct GetPartySelfSummaryError {
	/// Kind of error that occurred.
	pub kind: GetPartySelfSummaryErrorKind,
	/// Additional metadata about the error, including error code, message, and request ID.
	pub(crate) meta: aws_smithy_types::Error,
}
/// Types of errors that can occur for the `GetPartySelfSummary` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum GetPartySelfSummaryErrorKind {
	/// An error caused by internal server problems.
	InternalError(crate::error::InternalError),
	/// An error thrown when the requestee has hit a rate limit. You are sending too many requests too quickly.
	RateLimitError(crate::error::RateLimitError),
	/// An error thrown when the requestee requests a resource they do not have access to.
	ForbiddenError(crate::error::ForbiddenError),
	/// An error thrown when the requestee is not authenticated.
	UnauthorizedError(crate::error::UnauthorizedError),
	/// An error thrown when the requestee requests a non existant resource.
	NotFoundError(crate::error::NotFoundError),
	/// An error thrown when the requestee has sent an invalid or malformed request.
	BadRequestError(crate::error::BadRequestError),
	/// An unexpected error, e.g. invalid JSON returned by the service or an unknown error code
	Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for GetPartySelfSummaryError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		match &self.kind {
			GetPartySelfSummaryErrorKind::InternalError(_inner) => _inner.fmt(f),
			GetPartySelfSummaryErrorKind::RateLimitError(_inner) => _inner.fmt(f),
			GetPartySelfSummaryErrorKind::ForbiddenError(_inner) => _inner.fmt(f),
			GetPartySelfSummaryErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
			GetPartySelfSummaryErrorKind::NotFoundError(_inner) => _inner.fmt(f),
			GetPartySelfSummaryErrorKind::BadRequestError(_inner) => _inner.fmt(f),
			GetPartySelfSummaryErrorKind::Unhandled(_inner) => _inner.fmt(f),
		}
	}
}
impl aws_smithy_types::retry::ProvideErrorKind for GetPartySelfSummaryError {
	fn code(&self) -> Option<&str> {
		GetPartySelfSummaryError::code(self)
	}
	fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
		match &self.kind {
			GetPartySelfSummaryErrorKind::InternalError(inner) => {
				Some(inner.retryable_error_kind())
			}
			GetPartySelfSummaryErrorKind::UnauthorizedError(inner) => {
				Some(inner.retryable_error_kind())
			}
			_ => None,
		}
	}
}
impl GetPartySelfSummaryError {
	/// Creates a new `GetPartySelfSummaryError`.
	pub fn new(kind: GetPartySelfSummaryErrorKind, meta: aws_smithy_types::Error) -> Self {
		Self { kind, meta }
	}

	/// Creates the `GetPartySelfSummaryError::Unhandled` variant from any error type.
	pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
		Self {
			kind: GetPartySelfSummaryErrorKind::Unhandled(err.into()),
			meta: Default::default(),
		}
	}

	/// Creates the `GetPartySelfSummaryError::Unhandled` variant from a `aws_smithy_types::Error`.
	pub fn generic(err: aws_smithy_types::Error) -> Self {
		Self {
			meta: err.clone(),
			kind: GetPartySelfSummaryErrorKind::Unhandled(err.into()),
		}
	}

	/// Returns the error message if one is available.
	pub fn message(&self) -> Option<&str> {
		self.meta.message()
	}

	/// Returns error metadata, which includes the error code, message,
	/// request ID, and potentially additional information.
	pub fn meta(&self) -> &aws_smithy_types::Error {
		&self.meta
	}

	/// Returns the request ID if it's available.
	pub fn request_id(&self) -> Option<&str> {
		self.meta.request_id()
	}

	/// Returns the error code if it's available.
	pub fn code(&self) -> Option<&str> {
		self.meta.code()
	}
	/// Returns `true` if the error kind is `GetPartySelfSummaryErrorKind::InternalError`.
	pub fn is_internal_error(&self) -> bool {
		matches!(&self.kind, GetPartySelfSummaryErrorKind::InternalError(_))
	}
	/// Returns `true` if the error kind is `GetPartySelfSummaryErrorKind::RateLimitError`.
	pub fn is_rate_limit_error(&self) -> bool {
		matches!(&self.kind, GetPartySelfSummaryErrorKind::RateLimitError(_))
	}
	/// Returns `true` if the error kind is `GetPartySelfSummaryErrorKind::ForbiddenError`.
	pub fn is_forbidden_error(&self) -> bool {
		matches!(&self.kind, GetPartySelfSummaryErrorKind::ForbiddenError(_))
	}
	/// Returns `true` if the error kind is `GetPartySelfSummaryErrorKind::UnauthorizedError`.
	pub fn is_unauthorized_error(&self) -> bool {
		matches!(
			&self.kind,
			GetPartySelfSummaryErrorKind::UnauthorizedError(_)
		)
	}
	/// Returns `true` if the error kind is `GetPartySelfSummaryErrorKind::NotFoundError`.
	pub fn is_not_found_error(&self) -> bool {
		matches!(&self.kind, GetPartySelfSummaryErrorKind::NotFoundError(_))
	}
	/// Returns `true` if the error kind is `GetPartySelfSummaryErrorKind::BadRequestError`.
	pub fn is_bad_request_error(&self) -> bool {
		matches!(&self.kind, GetPartySelfSummaryErrorKind::BadRequestError(_))
	}
}
impl std::error::Error for GetPartySelfSummaryError {
	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
		match &self.kind {
			GetPartySelfSummaryErrorKind::InternalError(_inner) => Some(_inner),
			GetPartySelfSummaryErrorKind::RateLimitError(_inner) => Some(_inner),
			GetPartySelfSummaryErrorKind::ForbiddenError(_inner) => Some(_inner),
			GetPartySelfSummaryErrorKind::UnauthorizedError(_inner) => Some(_inner),
			GetPartySelfSummaryErrorKind::NotFoundError(_inner) => Some(_inner),
			GetPartySelfSummaryErrorKind::BadRequestError(_inner) => Some(_inner),
			GetPartySelfSummaryErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
		}
	}
}

/// Error type for the `GetPartySummary` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct GetPartySummaryError {
	/// Kind of error that occurred.
	pub kind: GetPartySummaryErrorKind,
	/// Additional metadata about the error, including error code, message, and request ID.
	pub(crate) meta: aws_smithy_types::Error,
}
/// Types of errors that can occur for the `GetPartySummary` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum GetPartySummaryErrorKind {
	/// An error caused by internal server problems.
	InternalError(crate::error::InternalError),
	/// An error thrown when the requestee has hit a rate limit. You are sending too many requests too quickly.
	RateLimitError(crate::error::RateLimitError),
	/// An error thrown when the requestee requests a resource they do not have access to.
	ForbiddenError(crate::error::ForbiddenError),
	/// An error thrown when the requestee is not authenticated.
	UnauthorizedError(crate::error::UnauthorizedError),
	/// An error thrown when the requestee requests a non existant resource.
	NotFoundError(crate::error::NotFoundError),
	/// An error thrown when the requestee has sent an invalid or malformed request.
	BadRequestError(crate::error::BadRequestError),
	/// An unexpected error, e.g. invalid JSON returned by the service or an unknown error code
	Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for GetPartySummaryError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		match &self.kind {
			GetPartySummaryErrorKind::InternalError(_inner) => _inner.fmt(f),
			GetPartySummaryErrorKind::RateLimitError(_inner) => _inner.fmt(f),
			GetPartySummaryErrorKind::ForbiddenError(_inner) => _inner.fmt(f),
			GetPartySummaryErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
			GetPartySummaryErrorKind::NotFoundError(_inner) => _inner.fmt(f),
			GetPartySummaryErrorKind::BadRequestError(_inner) => _inner.fmt(f),
			GetPartySummaryErrorKind::Unhandled(_inner) => _inner.fmt(f),
		}
	}
}
impl aws_smithy_types::retry::ProvideErrorKind for GetPartySummaryError {
	fn code(&self) -> Option<&str> {
		GetPartySummaryError::code(self)
	}
	fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
		match &self.kind {
			GetPartySummaryErrorKind::InternalError(inner) => Some(inner.retryable_error_kind()),
			GetPartySummaryErrorKind::UnauthorizedError(inner) => {
				Some(inner.retryable_error_kind())
			}
			_ => None,
		}
	}
}
impl GetPartySummaryError {
	/// Creates a new `GetPartySummaryError`.
	pub fn new(kind: GetPartySummaryErrorKind, meta: aws_smithy_types::Error) -> Self {
		Self { kind, meta }
	}

	/// Creates the `GetPartySummaryError::Unhandled` variant from any error type.
	pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
		Self {
			kind: GetPartySummaryErrorKind::Unhandled(err.into()),
			meta: Default::default(),
		}
	}

	/// Creates the `GetPartySummaryError::Unhandled` variant from a `aws_smithy_types::Error`.
	pub fn generic(err: aws_smithy_types::Error) -> Self {
		Self {
			meta: err.clone(),
			kind: GetPartySummaryErrorKind::Unhandled(err.into()),
		}
	}

	/// Returns the error message if one is available.
	pub fn message(&self) -> Option<&str> {
		self.meta.message()
	}

	/// Returns error metadata, which includes the error code, message,
	/// request ID, and potentially additional information.
	pub fn meta(&self) -> &aws_smithy_types::Error {
		&self.meta
	}

	/// Returns the request ID if it's available.
	pub fn request_id(&self) -> Option<&str> {
		self.meta.request_id()
	}

	/// Returns the error code if it's available.
	pub fn code(&self) -> Option<&str> {
		self.meta.code()
	}
	/// Returns `true` if the error kind is `GetPartySummaryErrorKind::InternalError`.
	pub fn is_internal_error(&self) -> bool {
		matches!(&self.kind, GetPartySummaryErrorKind::InternalError(_))
	}
	/// Returns `true` if the error kind is `GetPartySummaryErrorKind::RateLimitError`.
	pub fn is_rate_limit_error(&self) -> bool {
		matches!(&self.kind, GetPartySummaryErrorKind::RateLimitError(_))
	}
	/// Returns `true` if the error kind is `GetPartySummaryErrorKind::ForbiddenError`.
	pub fn is_forbidden_error(&self) -> bool {
		matches!(&self.kind, GetPartySummaryErrorKind::ForbiddenError(_))
	}
	/// Returns `true` if the error kind is `GetPartySummaryErrorKind::UnauthorizedError`.
	pub fn is_unauthorized_error(&self) -> bool {
		matches!(&self.kind, GetPartySummaryErrorKind::UnauthorizedError(_))
	}
	/// Returns `true` if the error kind is `GetPartySummaryErrorKind::NotFoundError`.
	pub fn is_not_found_error(&self) -> bool {
		matches!(&self.kind, GetPartySummaryErrorKind::NotFoundError(_))
	}
	/// Returns `true` if the error kind is `GetPartySummaryErrorKind::BadRequestError`.
	pub fn is_bad_request_error(&self) -> bool {
		matches!(&self.kind, GetPartySummaryErrorKind::BadRequestError(_))
	}
}
impl std::error::Error for GetPartySummaryError {
	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
		match &self.kind {
			GetPartySummaryErrorKind::InternalError(_inner) => Some(_inner),
			GetPartySummaryErrorKind::RateLimitError(_inner) => Some(_inner),
			GetPartySummaryErrorKind::ForbiddenError(_inner) => Some(_inner),
			GetPartySummaryErrorKind::UnauthorizedError(_inner) => Some(_inner),
			GetPartySummaryErrorKind::NotFoundError(_inner) => Some(_inner),
			GetPartySummaryErrorKind::BadRequestError(_inner) => Some(_inner),
			GetPartySummaryErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
		}
	}
}

/// Error type for the `JoinParty` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct JoinPartyError {
	/// Kind of error that occurred.
	pub kind: JoinPartyErrorKind,
	/// Additional metadata about the error, including error code, message, and request ID.
	pub(crate) meta: aws_smithy_types::Error,
}
/// Types of errors that can occur for the `JoinParty` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum JoinPartyErrorKind {
	/// An error caused by internal server problems.
	InternalError(crate::error::InternalError),
	/// An error thrown when the requestee has hit a rate limit. You are sending too many requests too quickly.
	RateLimitError(crate::error::RateLimitError),
	/// An error thrown when the requestee requests a resource they do not have access to.
	ForbiddenError(crate::error::ForbiddenError),
	/// An error thrown when the requestee is not authenticated.
	UnauthorizedError(crate::error::UnauthorizedError),
	/// An error thrown when the requestee requests a non existant resource.
	NotFoundError(crate::error::NotFoundError),
	/// An error thrown when the requestee has sent an invalid or malformed request.
	BadRequestError(crate::error::BadRequestError),
	/// An unexpected error, e.g. invalid JSON returned by the service or an unknown error code
	Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for JoinPartyError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		match &self.kind {
			JoinPartyErrorKind::InternalError(_inner) => _inner.fmt(f),
			JoinPartyErrorKind::RateLimitError(_inner) => _inner.fmt(f),
			JoinPartyErrorKind::ForbiddenError(_inner) => _inner.fmt(f),
			JoinPartyErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
			JoinPartyErrorKind::NotFoundError(_inner) => _inner.fmt(f),
			JoinPartyErrorKind::BadRequestError(_inner) => _inner.fmt(f),
			JoinPartyErrorKind::Unhandled(_inner) => _inner.fmt(f),
		}
	}
}
impl aws_smithy_types::retry::ProvideErrorKind for JoinPartyError {
	fn code(&self) -> Option<&str> {
		JoinPartyError::code(self)
	}
	fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
		match &self.kind {
			JoinPartyErrorKind::InternalError(inner) => Some(inner.retryable_error_kind()),
			JoinPartyErrorKind::UnauthorizedError(inner) => Some(inner.retryable_error_kind()),
			_ => None,
		}
	}
}
impl JoinPartyError {
	/// Creates a new `JoinPartyError`.
	pub fn new(kind: JoinPartyErrorKind, meta: aws_smithy_types::Error) -> Self {
		Self { kind, meta }
	}

	/// Creates the `JoinPartyError::Unhandled` variant from any error type.
	pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
		Self {
			kind: JoinPartyErrorKind::Unhandled(err.into()),
			meta: Default::default(),
		}
	}

	/// Creates the `JoinPartyError::Unhandled` variant from a `aws_smithy_types::Error`.
	pub fn generic(err: aws_smithy_types::Error) -> Self {
		Self {
			meta: err.clone(),
			kind: JoinPartyErrorKind::Unhandled(err.into()),
		}
	}

	/// Returns the error message if one is available.
	pub fn message(&self) -> Option<&str> {
		self.meta.message()
	}

	/// Returns error metadata, which includes the error code, message,
	/// request ID, and potentially additional information.
	pub fn meta(&self) -> &aws_smithy_types::Error {
		&self.meta
	}

	/// Returns the request ID if it's available.
	pub fn request_id(&self) -> Option<&str> {
		self.meta.request_id()
	}

	/// Returns the error code if it's available.
	pub fn code(&self) -> Option<&str> {
		self.meta.code()
	}
	/// Returns `true` if the error kind is `JoinPartyErrorKind::InternalError`.
	pub fn is_internal_error(&self) -> bool {
		matches!(&self.kind, JoinPartyErrorKind::InternalError(_))
	}
	/// Returns `true` if the error kind is `JoinPartyErrorKind::RateLimitError`.
	pub fn is_rate_limit_error(&self) -> bool {
		matches!(&self.kind, JoinPartyErrorKind::RateLimitError(_))
	}
	/// Returns `true` if the error kind is `JoinPartyErrorKind::ForbiddenError`.
	pub fn is_forbidden_error(&self) -> bool {
		matches!(&self.kind, JoinPartyErrorKind::ForbiddenError(_))
	}
	/// Returns `true` if the error kind is `JoinPartyErrorKind::UnauthorizedError`.
	pub fn is_unauthorized_error(&self) -> bool {
		matches!(&self.kind, JoinPartyErrorKind::UnauthorizedError(_))
	}
	/// Returns `true` if the error kind is `JoinPartyErrorKind::NotFoundError`.
	pub fn is_not_found_error(&self) -> bool {
		matches!(&self.kind, JoinPartyErrorKind::NotFoundError(_))
	}
	/// Returns `true` if the error kind is `JoinPartyErrorKind::BadRequestError`.
	pub fn is_bad_request_error(&self) -> bool {
		matches!(&self.kind, JoinPartyErrorKind::BadRequestError(_))
	}
}
impl std::error::Error for JoinPartyError {
	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
		match &self.kind {
			JoinPartyErrorKind::InternalError(_inner) => Some(_inner),
			JoinPartyErrorKind::RateLimitError(_inner) => Some(_inner),
			JoinPartyErrorKind::ForbiddenError(_inner) => Some(_inner),
			JoinPartyErrorKind::UnauthorizedError(_inner) => Some(_inner),
			JoinPartyErrorKind::NotFoundError(_inner) => Some(_inner),
			JoinPartyErrorKind::BadRequestError(_inner) => Some(_inner),
			JoinPartyErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
		}
	}
}

/// Error type for the `KickMember` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct KickMemberError {
	/// Kind of error that occurred.
	pub kind: KickMemberErrorKind,
	/// Additional metadata about the error, including error code, message, and request ID.
	pub(crate) meta: aws_smithy_types::Error,
}
/// Types of errors that can occur for the `KickMember` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum KickMemberErrorKind {
	/// An error caused by internal server problems.
	InternalError(crate::error::InternalError),
	/// An error thrown when the requestee has hit a rate limit. You are sending too many requests too quickly.
	RateLimitError(crate::error::RateLimitError),
	/// An error thrown when the requestee requests a resource they do not have access to.
	ForbiddenError(crate::error::ForbiddenError),
	/// An error thrown when the requestee is not authenticated.
	UnauthorizedError(crate::error::UnauthorizedError),
	/// An error thrown when the requestee requests a non existant resource.
	NotFoundError(crate::error::NotFoundError),
	/// An error thrown when the requestee has sent an invalid or malformed request.
	BadRequestError(crate::error::BadRequestError),
	/// An unexpected error, e.g. invalid JSON returned by the service or an unknown error code
	Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for KickMemberError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		match &self.kind {
			KickMemberErrorKind::InternalError(_inner) => _inner.fmt(f),
			KickMemberErrorKind::RateLimitError(_inner) => _inner.fmt(f),
			KickMemberErrorKind::ForbiddenError(_inner) => _inner.fmt(f),
			KickMemberErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
			KickMemberErrorKind::NotFoundError(_inner) => _inner.fmt(f),
			KickMemberErrorKind::BadRequestError(_inner) => _inner.fmt(f),
			KickMemberErrorKind::Unhandled(_inner) => _inner.fmt(f),
		}
	}
}
impl aws_smithy_types::retry::ProvideErrorKind for KickMemberError {
	fn code(&self) -> Option<&str> {
		KickMemberError::code(self)
	}
	fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
		match &self.kind {
			KickMemberErrorKind::InternalError(inner) => Some(inner.retryable_error_kind()),
			KickMemberErrorKind::UnauthorizedError(inner) => Some(inner.retryable_error_kind()),
			_ => None,
		}
	}
}
impl KickMemberError {
	/// Creates a new `KickMemberError`.
	pub fn new(kind: KickMemberErrorKind, meta: aws_smithy_types::Error) -> Self {
		Self { kind, meta }
	}

	/// Creates the `KickMemberError::Unhandled` variant from any error type.
	pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
		Self {
			kind: KickMemberErrorKind::Unhandled(err.into()),
			meta: Default::default(),
		}
	}

	/// Creates the `KickMemberError::Unhandled` variant from a `aws_smithy_types::Error`.
	pub fn generic(err: aws_smithy_types::Error) -> Self {
		Self {
			meta: err.clone(),
			kind: KickMemberErrorKind::Unhandled(err.into()),
		}
	}

	/// Returns the error message if one is available.
	pub fn message(&self) -> Option<&str> {
		self.meta.message()
	}

	/// Returns error metadata, which includes the error code, message,
	/// request ID, and potentially additional information.
	pub fn meta(&self) -> &aws_smithy_types::Error {
		&self.meta
	}

	/// Returns the request ID if it's available.
	pub fn request_id(&self) -> Option<&str> {
		self.meta.request_id()
	}

	/// Returns the error code if it's available.
	pub fn code(&self) -> Option<&str> {
		self.meta.code()
	}
	/// Returns `true` if the error kind is `KickMemberErrorKind::InternalError`.
	pub fn is_internal_error(&self) -> bool {
		matches!(&self.kind, KickMemberErrorKind::InternalError(_))
	}
	/// Returns `true` if the error kind is `KickMemberErrorKind::RateLimitError`.
	pub fn is_rate_limit_error(&self) -> bool {
		matches!(&self.kind, KickMemberErrorKind::RateLimitError(_))
	}
	/// Returns `true` if the error kind is `KickMemberErrorKind::ForbiddenError`.
	pub fn is_forbidden_error(&self) -> bool {
		matches!(&self.kind, KickMemberErrorKind::ForbiddenError(_))
	}
	/// Returns `true` if the error kind is `KickMemberErrorKind::UnauthorizedError`.
	pub fn is_unauthorized_error(&self) -> bool {
		matches!(&self.kind, KickMemberErrorKind::UnauthorizedError(_))
	}
	/// Returns `true` if the error kind is `KickMemberErrorKind::NotFoundError`.
	pub fn is_not_found_error(&self) -> bool {
		matches!(&self.kind, KickMemberErrorKind::NotFoundError(_))
	}
	/// Returns `true` if the error kind is `KickMemberErrorKind::BadRequestError`.
	pub fn is_bad_request_error(&self) -> bool {
		matches!(&self.kind, KickMemberErrorKind::BadRequestError(_))
	}
}
impl std::error::Error for KickMemberError {
	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
		match &self.kind {
			KickMemberErrorKind::InternalError(_inner) => Some(_inner),
			KickMemberErrorKind::RateLimitError(_inner) => Some(_inner),
			KickMemberErrorKind::ForbiddenError(_inner) => Some(_inner),
			KickMemberErrorKind::UnauthorizedError(_inner) => Some(_inner),
			KickMemberErrorKind::NotFoundError(_inner) => Some(_inner),
			KickMemberErrorKind::BadRequestError(_inner) => Some(_inner),
			KickMemberErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
		}
	}
}

/// Error type for the `LeaveParty` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct LeavePartyError {
	/// Kind of error that occurred.
	pub kind: LeavePartyErrorKind,
	/// Additional metadata about the error, including error code, message, and request ID.
	pub(crate) meta: aws_smithy_types::Error,
}
/// Types of errors that can occur for the `LeaveParty` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum LeavePartyErrorKind {
	/// An error caused by internal server problems.
	InternalError(crate::error::InternalError),
	/// An error thrown when the requestee has hit a rate limit. You are sending too many requests too quickly.
	RateLimitError(crate::error::RateLimitError),
	/// An error thrown when the requestee requests a resource they do not have access to.
	ForbiddenError(crate::error::ForbiddenError),
	/// An error thrown when the requestee is not authenticated.
	UnauthorizedError(crate::error::UnauthorizedError),
	/// An error thrown when the requestee requests a non existant resource.
	NotFoundError(crate::error::NotFoundError),
	/// An error thrown when the requestee has sent an invalid or malformed request.
	BadRequestError(crate::error::BadRequestError),
	/// An unexpected error, e.g. invalid JSON returned by the service or an unknown error code
	Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for LeavePartyError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		match &self.kind {
			LeavePartyErrorKind::InternalError(_inner) => _inner.fmt(f),
			LeavePartyErrorKind::RateLimitError(_inner) => _inner.fmt(f),
			LeavePartyErrorKind::ForbiddenError(_inner) => _inner.fmt(f),
			LeavePartyErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
			LeavePartyErrorKind::NotFoundError(_inner) => _inner.fmt(f),
			LeavePartyErrorKind::BadRequestError(_inner) => _inner.fmt(f),
			LeavePartyErrorKind::Unhandled(_inner) => _inner.fmt(f),
		}
	}
}
impl aws_smithy_types::retry::ProvideErrorKind for LeavePartyError {
	fn code(&self) -> Option<&str> {
		LeavePartyError::code(self)
	}
	fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
		match &self.kind {
			LeavePartyErrorKind::InternalError(inner) => Some(inner.retryable_error_kind()),
			LeavePartyErrorKind::UnauthorizedError(inner) => Some(inner.retryable_error_kind()),
			_ => None,
		}
	}
}
impl LeavePartyError {
	/// Creates a new `LeavePartyError`.
	pub fn new(kind: LeavePartyErrorKind, meta: aws_smithy_types::Error) -> Self {
		Self { kind, meta }
	}

	/// Creates the `LeavePartyError::Unhandled` variant from any error type.
	pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
		Self {
			kind: LeavePartyErrorKind::Unhandled(err.into()),
			meta: Default::default(),
		}
	}

	/// Creates the `LeavePartyError::Unhandled` variant from a `aws_smithy_types::Error`.
	pub fn generic(err: aws_smithy_types::Error) -> Self {
		Self {
			meta: err.clone(),
			kind: LeavePartyErrorKind::Unhandled(err.into()),
		}
	}

	/// Returns the error message if one is available.
	pub fn message(&self) -> Option<&str> {
		self.meta.message()
	}

	/// Returns error metadata, which includes the error code, message,
	/// request ID, and potentially additional information.
	pub fn meta(&self) -> &aws_smithy_types::Error {
		&self.meta
	}

	/// Returns the request ID if it's available.
	pub fn request_id(&self) -> Option<&str> {
		self.meta.request_id()
	}

	/// Returns the error code if it's available.
	pub fn code(&self) -> Option<&str> {
		self.meta.code()
	}
	/// Returns `true` if the error kind is `LeavePartyErrorKind::InternalError`.
	pub fn is_internal_error(&self) -> bool {
		matches!(&self.kind, LeavePartyErrorKind::InternalError(_))
	}
	/// Returns `true` if the error kind is `LeavePartyErrorKind::RateLimitError`.
	pub fn is_rate_limit_error(&self) -> bool {
		matches!(&self.kind, LeavePartyErrorKind::RateLimitError(_))
	}
	/// Returns `true` if the error kind is `LeavePartyErrorKind::ForbiddenError`.
	pub fn is_forbidden_error(&self) -> bool {
		matches!(&self.kind, LeavePartyErrorKind::ForbiddenError(_))
	}
	/// Returns `true` if the error kind is `LeavePartyErrorKind::UnauthorizedError`.
	pub fn is_unauthorized_error(&self) -> bool {
		matches!(&self.kind, LeavePartyErrorKind::UnauthorizedError(_))
	}
	/// Returns `true` if the error kind is `LeavePartyErrorKind::NotFoundError`.
	pub fn is_not_found_error(&self) -> bool {
		matches!(&self.kind, LeavePartyErrorKind::NotFoundError(_))
	}
	/// Returns `true` if the error kind is `LeavePartyErrorKind::BadRequestError`.
	pub fn is_bad_request_error(&self) -> bool {
		matches!(&self.kind, LeavePartyErrorKind::BadRequestError(_))
	}
}
impl std::error::Error for LeavePartyError {
	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
		match &self.kind {
			LeavePartyErrorKind::InternalError(_inner) => Some(_inner),
			LeavePartyErrorKind::RateLimitError(_inner) => Some(_inner),
			LeavePartyErrorKind::ForbiddenError(_inner) => Some(_inner),
			LeavePartyErrorKind::UnauthorizedError(_inner) => Some(_inner),
			LeavePartyErrorKind::NotFoundError(_inner) => Some(_inner),
			LeavePartyErrorKind::BadRequestError(_inner) => Some(_inner),
			LeavePartyErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
		}
	}
}

/// Error type for the `RevokePartyInvite` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct RevokePartyInviteError {
	/// Kind of error that occurred.
	pub kind: RevokePartyInviteErrorKind,
	/// Additional metadata about the error, including error code, message, and request ID.
	pub(crate) meta: aws_smithy_types::Error,
}
/// Types of errors that can occur for the `RevokePartyInvite` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum RevokePartyInviteErrorKind {
	/// An error caused by internal server problems.
	InternalError(crate::error::InternalError),
	/// An error thrown when the requestee has hit a rate limit. You are sending too many requests too quickly.
	RateLimitError(crate::error::RateLimitError),
	/// An error thrown when the requestee requests a resource they do not have access to.
	ForbiddenError(crate::error::ForbiddenError),
	/// An error thrown when the requestee is not authenticated.
	UnauthorizedError(crate::error::UnauthorizedError),
	/// An error thrown when the requestee requests a non existant resource.
	NotFoundError(crate::error::NotFoundError),
	/// An error thrown when the requestee has sent an invalid or malformed request.
	BadRequestError(crate::error::BadRequestError),
	/// An unexpected error, e.g. invalid JSON returned by the service or an unknown error code
	Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for RevokePartyInviteError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		match &self.kind {
			RevokePartyInviteErrorKind::InternalError(_inner) => _inner.fmt(f),
			RevokePartyInviteErrorKind::RateLimitError(_inner) => _inner.fmt(f),
			RevokePartyInviteErrorKind::ForbiddenError(_inner) => _inner.fmt(f),
			RevokePartyInviteErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
			RevokePartyInviteErrorKind::NotFoundError(_inner) => _inner.fmt(f),
			RevokePartyInviteErrorKind::BadRequestError(_inner) => _inner.fmt(f),
			RevokePartyInviteErrorKind::Unhandled(_inner) => _inner.fmt(f),
		}
	}
}
impl aws_smithy_types::retry::ProvideErrorKind for RevokePartyInviteError {
	fn code(&self) -> Option<&str> {
		RevokePartyInviteError::code(self)
	}
	fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
		match &self.kind {
			RevokePartyInviteErrorKind::InternalError(inner) => Some(inner.retryable_error_kind()),
			RevokePartyInviteErrorKind::UnauthorizedError(inner) => {
				Some(inner.retryable_error_kind())
			}
			_ => None,
		}
	}
}
impl RevokePartyInviteError {
	/// Creates a new `RevokePartyInviteError`.
	pub fn new(kind: RevokePartyInviteErrorKind, meta: aws_smithy_types::Error) -> Self {
		Self { kind, meta }
	}

	/// Creates the `RevokePartyInviteError::Unhandled` variant from any error type.
	pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
		Self {
			kind: RevokePartyInviteErrorKind::Unhandled(err.into()),
			meta: Default::default(),
		}
	}

	/// Creates the `RevokePartyInviteError::Unhandled` variant from a `aws_smithy_types::Error`.
	pub fn generic(err: aws_smithy_types::Error) -> Self {
		Self {
			meta: err.clone(),
			kind: RevokePartyInviteErrorKind::Unhandled(err.into()),
		}
	}

	/// Returns the error message if one is available.
	pub fn message(&self) -> Option<&str> {
		self.meta.message()
	}

	/// Returns error metadata, which includes the error code, message,
	/// request ID, and potentially additional information.
	pub fn meta(&self) -> &aws_smithy_types::Error {
		&self.meta
	}

	/// Returns the request ID if it's available.
	pub fn request_id(&self) -> Option<&str> {
		self.meta.request_id()
	}

	/// Returns the error code if it's available.
	pub fn code(&self) -> Option<&str> {
		self.meta.code()
	}
	/// Returns `true` if the error kind is `RevokePartyInviteErrorKind::InternalError`.
	pub fn is_internal_error(&self) -> bool {
		matches!(&self.kind, RevokePartyInviteErrorKind::InternalError(_))
	}
	/// Returns `true` if the error kind is `RevokePartyInviteErrorKind::RateLimitError`.
	pub fn is_rate_limit_error(&self) -> bool {
		matches!(&self.kind, RevokePartyInviteErrorKind::RateLimitError(_))
	}
	/// Returns `true` if the error kind is `RevokePartyInviteErrorKind::ForbiddenError`.
	pub fn is_forbidden_error(&self) -> bool {
		matches!(&self.kind, RevokePartyInviteErrorKind::ForbiddenError(_))
	}
	/// Returns `true` if the error kind is `RevokePartyInviteErrorKind::UnauthorizedError`.
	pub fn is_unauthorized_error(&self) -> bool {
		matches!(&self.kind, RevokePartyInviteErrorKind::UnauthorizedError(_))
	}
	/// Returns `true` if the error kind is `RevokePartyInviteErrorKind::NotFoundError`.
	pub fn is_not_found_error(&self) -> bool {
		matches!(&self.kind, RevokePartyInviteErrorKind::NotFoundError(_))
	}
	/// Returns `true` if the error kind is `RevokePartyInviteErrorKind::BadRequestError`.
	pub fn is_bad_request_error(&self) -> bool {
		matches!(&self.kind, RevokePartyInviteErrorKind::BadRequestError(_))
	}
}
impl std::error::Error for RevokePartyInviteError {
	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
		match &self.kind {
			RevokePartyInviteErrorKind::InternalError(_inner) => Some(_inner),
			RevokePartyInviteErrorKind::RateLimitError(_inner) => Some(_inner),
			RevokePartyInviteErrorKind::ForbiddenError(_inner) => Some(_inner),
			RevokePartyInviteErrorKind::UnauthorizedError(_inner) => Some(_inner),
			RevokePartyInviteErrorKind::NotFoundError(_inner) => Some(_inner),
			RevokePartyInviteErrorKind::BadRequestError(_inner) => Some(_inner),
			RevokePartyInviteErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
		}
	}
}

/// Error type for the `SendJoinRequest` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct SendJoinRequestError {
	/// Kind of error that occurred.
	pub kind: SendJoinRequestErrorKind,
	/// Additional metadata about the error, including error code, message, and request ID.
	pub(crate) meta: aws_smithy_types::Error,
}
/// Types of errors that can occur for the `SendJoinRequest` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum SendJoinRequestErrorKind {
	/// An error caused by internal server problems.
	InternalError(crate::error::InternalError),
	/// An error thrown when the requestee has hit a rate limit. You are sending too many requests too quickly.
	RateLimitError(crate::error::RateLimitError),
	/// An error thrown when the requestee requests a resource they do not have access to.
	ForbiddenError(crate::error::ForbiddenError),
	/// An error thrown when the requestee is not authenticated.
	UnauthorizedError(crate::error::UnauthorizedError),
	/// An error thrown when the requestee requests a non existant resource.
	NotFoundError(crate::error::NotFoundError),
	/// An error thrown when the requestee has sent an invalid or malformed request.
	BadRequestError(crate::error::BadRequestError),
	/// An unexpected error, e.g. invalid JSON returned by the service or an unknown error code
	Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for SendJoinRequestError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		match &self.kind {
			SendJoinRequestErrorKind::InternalError(_inner) => _inner.fmt(f),
			SendJoinRequestErrorKind::RateLimitError(_inner) => _inner.fmt(f),
			SendJoinRequestErrorKind::ForbiddenError(_inner) => _inner.fmt(f),
			SendJoinRequestErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
			SendJoinRequestErrorKind::NotFoundError(_inner) => _inner.fmt(f),
			SendJoinRequestErrorKind::BadRequestError(_inner) => _inner.fmt(f),
			SendJoinRequestErrorKind::Unhandled(_inner) => _inner.fmt(f),
		}
	}
}
impl aws_smithy_types::retry::ProvideErrorKind for SendJoinRequestError {
	fn code(&self) -> Option<&str> {
		SendJoinRequestError::code(self)
	}
	fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
		match &self.kind {
			SendJoinRequestErrorKind::InternalError(inner) => Some(inner.retryable_error_kind()),
			SendJoinRequestErrorKind::UnauthorizedError(inner) => {
				Some(inner.retryable_error_kind())
			}
			_ => None,
		}
	}
}
impl SendJoinRequestError {
	/// Creates a new `SendJoinRequestError`.
	pub fn new(kind: SendJoinRequestErrorKind, meta: aws_smithy_types::Error) -> Self {
		Self { kind, meta }
	}

	/// Creates the `SendJoinRequestError::Unhandled` variant from any error type.
	pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
		Self {
			kind: SendJoinRequestErrorKind::Unhandled(err.into()),
			meta: Default::default(),
		}
	}

	/// Creates the `SendJoinRequestError::Unhandled` variant from a `aws_smithy_types::Error`.
	pub fn generic(err: aws_smithy_types::Error) -> Self {
		Self {
			meta: err.clone(),
			kind: SendJoinRequestErrorKind::Unhandled(err.into()),
		}
	}

	/// Returns the error message if one is available.
	pub fn message(&self) -> Option<&str> {
		self.meta.message()
	}

	/// Returns error metadata, which includes the error code, message,
	/// request ID, and potentially additional information.
	pub fn meta(&self) -> &aws_smithy_types::Error {
		&self.meta
	}

	/// Returns the request ID if it's available.
	pub fn request_id(&self) -> Option<&str> {
		self.meta.request_id()
	}

	/// Returns the error code if it's available.
	pub fn code(&self) -> Option<&str> {
		self.meta.code()
	}
	/// Returns `true` if the error kind is `SendJoinRequestErrorKind::InternalError`.
	pub fn is_internal_error(&self) -> bool {
		matches!(&self.kind, SendJoinRequestErrorKind::InternalError(_))
	}
	/// Returns `true` if the error kind is `SendJoinRequestErrorKind::RateLimitError`.
	pub fn is_rate_limit_error(&self) -> bool {
		matches!(&self.kind, SendJoinRequestErrorKind::RateLimitError(_))
	}
	/// Returns `true` if the error kind is `SendJoinRequestErrorKind::ForbiddenError`.
	pub fn is_forbidden_error(&self) -> bool {
		matches!(&self.kind, SendJoinRequestErrorKind::ForbiddenError(_))
	}
	/// Returns `true` if the error kind is `SendJoinRequestErrorKind::UnauthorizedError`.
	pub fn is_unauthorized_error(&self) -> bool {
		matches!(&self.kind, SendJoinRequestErrorKind::UnauthorizedError(_))
	}
	/// Returns `true` if the error kind is `SendJoinRequestErrorKind::NotFoundError`.
	pub fn is_not_found_error(&self) -> bool {
		matches!(&self.kind, SendJoinRequestErrorKind::NotFoundError(_))
	}
	/// Returns `true` if the error kind is `SendJoinRequestErrorKind::BadRequestError`.
	pub fn is_bad_request_error(&self) -> bool {
		matches!(&self.kind, SendJoinRequestErrorKind::BadRequestError(_))
	}
}
impl std::error::Error for SendJoinRequestError {
	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
		match &self.kind {
			SendJoinRequestErrorKind::InternalError(_inner) => Some(_inner),
			SendJoinRequestErrorKind::RateLimitError(_inner) => Some(_inner),
			SendJoinRequestErrorKind::ForbiddenError(_inner) => Some(_inner),
			SendJoinRequestErrorKind::UnauthorizedError(_inner) => Some(_inner),
			SendJoinRequestErrorKind::NotFoundError(_inner) => Some(_inner),
			SendJoinRequestErrorKind::BadRequestError(_inner) => Some(_inner),
			SendJoinRequestErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
		}
	}
}

/// Error type for the `SetPartyPublicity` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct SetPartyPublicityError {
	/// Kind of error that occurred.
	pub kind: SetPartyPublicityErrorKind,
	/// Additional metadata about the error, including error code, message, and request ID.
	pub(crate) meta: aws_smithy_types::Error,
}
/// Types of errors that can occur for the `SetPartyPublicity` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum SetPartyPublicityErrorKind {
	/// An error caused by internal server problems.
	InternalError(crate::error::InternalError),
	/// An error thrown when the requestee has hit a rate limit. You are sending too many requests too quickly.
	RateLimitError(crate::error::RateLimitError),
	/// An error thrown when the requestee requests a resource they do not have access to.
	ForbiddenError(crate::error::ForbiddenError),
	/// An error thrown when the requestee is not authenticated.
	UnauthorizedError(crate::error::UnauthorizedError),
	/// An error thrown when the requestee requests a non existant resource.
	NotFoundError(crate::error::NotFoundError),
	/// An error thrown when the requestee has sent an invalid or malformed request.
	BadRequestError(crate::error::BadRequestError),
	/// An unexpected error, e.g. invalid JSON returned by the service or an unknown error code
	Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for SetPartyPublicityError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		match &self.kind {
			SetPartyPublicityErrorKind::InternalError(_inner) => _inner.fmt(f),
			SetPartyPublicityErrorKind::RateLimitError(_inner) => _inner.fmt(f),
			SetPartyPublicityErrorKind::ForbiddenError(_inner) => _inner.fmt(f),
			SetPartyPublicityErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
			SetPartyPublicityErrorKind::NotFoundError(_inner) => _inner.fmt(f),
			SetPartyPublicityErrorKind::BadRequestError(_inner) => _inner.fmt(f),
			SetPartyPublicityErrorKind::Unhandled(_inner) => _inner.fmt(f),
		}
	}
}
impl aws_smithy_types::retry::ProvideErrorKind for SetPartyPublicityError {
	fn code(&self) -> Option<&str> {
		SetPartyPublicityError::code(self)
	}
	fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
		match &self.kind {
			SetPartyPublicityErrorKind::InternalError(inner) => Some(inner.retryable_error_kind()),
			SetPartyPublicityErrorKind::UnauthorizedError(inner) => {
				Some(inner.retryable_error_kind())
			}
			_ => None,
		}
	}
}
impl SetPartyPublicityError {
	/// Creates a new `SetPartyPublicityError`.
	pub fn new(kind: SetPartyPublicityErrorKind, meta: aws_smithy_types::Error) -> Self {
		Self { kind, meta }
	}

	/// Creates the `SetPartyPublicityError::Unhandled` variant from any error type.
	pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
		Self {
			kind: SetPartyPublicityErrorKind::Unhandled(err.into()),
			meta: Default::default(),
		}
	}

	/// Creates the `SetPartyPublicityError::Unhandled` variant from a `aws_smithy_types::Error`.
	pub fn generic(err: aws_smithy_types::Error) -> Self {
		Self {
			meta: err.clone(),
			kind: SetPartyPublicityErrorKind::Unhandled(err.into()),
		}
	}

	/// Returns the error message if one is available.
	pub fn message(&self) -> Option<&str> {
		self.meta.message()
	}

	/// Returns error metadata, which includes the error code, message,
	/// request ID, and potentially additional information.
	pub fn meta(&self) -> &aws_smithy_types::Error {
		&self.meta
	}

	/// Returns the request ID if it's available.
	pub fn request_id(&self) -> Option<&str> {
		self.meta.request_id()
	}

	/// Returns the error code if it's available.
	pub fn code(&self) -> Option<&str> {
		self.meta.code()
	}
	/// Returns `true` if the error kind is `SetPartyPublicityErrorKind::InternalError`.
	pub fn is_internal_error(&self) -> bool {
		matches!(&self.kind, SetPartyPublicityErrorKind::InternalError(_))
	}
	/// Returns `true` if the error kind is `SetPartyPublicityErrorKind::RateLimitError`.
	pub fn is_rate_limit_error(&self) -> bool {
		matches!(&self.kind, SetPartyPublicityErrorKind::RateLimitError(_))
	}
	/// Returns `true` if the error kind is `SetPartyPublicityErrorKind::ForbiddenError`.
	pub fn is_forbidden_error(&self) -> bool {
		matches!(&self.kind, SetPartyPublicityErrorKind::ForbiddenError(_))
	}
	/// Returns `true` if the error kind is `SetPartyPublicityErrorKind::UnauthorizedError`.
	pub fn is_unauthorized_error(&self) -> bool {
		matches!(&self.kind, SetPartyPublicityErrorKind::UnauthorizedError(_))
	}
	/// Returns `true` if the error kind is `SetPartyPublicityErrorKind::NotFoundError`.
	pub fn is_not_found_error(&self) -> bool {
		matches!(&self.kind, SetPartyPublicityErrorKind::NotFoundError(_))
	}
	/// Returns `true` if the error kind is `SetPartyPublicityErrorKind::BadRequestError`.
	pub fn is_bad_request_error(&self) -> bool {
		matches!(&self.kind, SetPartyPublicityErrorKind::BadRequestError(_))
	}
}
impl std::error::Error for SetPartyPublicityError {
	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
		match &self.kind {
			SetPartyPublicityErrorKind::InternalError(_inner) => Some(_inner),
			SetPartyPublicityErrorKind::RateLimitError(_inner) => Some(_inner),
			SetPartyPublicityErrorKind::ForbiddenError(_inner) => Some(_inner),
			SetPartyPublicityErrorKind::UnauthorizedError(_inner) => Some(_inner),
			SetPartyPublicityErrorKind::NotFoundError(_inner) => Some(_inner),
			SetPartyPublicityErrorKind::BadRequestError(_inner) => Some(_inner),
			SetPartyPublicityErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
		}
	}
}

/// Error type for the `TransferPartyOwnership` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct TransferPartyOwnershipError {
	/// Kind of error that occurred.
	pub kind: TransferPartyOwnershipErrorKind,
	/// Additional metadata about the error, including error code, message, and request ID.
	pub(crate) meta: aws_smithy_types::Error,
}
/// Types of errors that can occur for the `TransferPartyOwnership` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum TransferPartyOwnershipErrorKind {
	/// An error caused by internal server problems.
	InternalError(crate::error::InternalError),
	/// An error thrown when the requestee has hit a rate limit. You are sending too many requests too quickly.
	RateLimitError(crate::error::RateLimitError),
	/// An error thrown when the requestee requests a resource they do not have access to.
	ForbiddenError(crate::error::ForbiddenError),
	/// An error thrown when the requestee is not authenticated.
	UnauthorizedError(crate::error::UnauthorizedError),
	/// An error thrown when the requestee requests a non existant resource.
	NotFoundError(crate::error::NotFoundError),
	/// An error thrown when the requestee has sent an invalid or malformed request.
	BadRequestError(crate::error::BadRequestError),
	/// An unexpected error, e.g. invalid JSON returned by the service or an unknown error code
	Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for TransferPartyOwnershipError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		match &self.kind {
			TransferPartyOwnershipErrorKind::InternalError(_inner) => _inner.fmt(f),
			TransferPartyOwnershipErrorKind::RateLimitError(_inner) => _inner.fmt(f),
			TransferPartyOwnershipErrorKind::ForbiddenError(_inner) => _inner.fmt(f),
			TransferPartyOwnershipErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
			TransferPartyOwnershipErrorKind::NotFoundError(_inner) => _inner.fmt(f),
			TransferPartyOwnershipErrorKind::BadRequestError(_inner) => _inner.fmt(f),
			TransferPartyOwnershipErrorKind::Unhandled(_inner) => _inner.fmt(f),
		}
	}
}
impl aws_smithy_types::retry::ProvideErrorKind for TransferPartyOwnershipError {
	fn code(&self) -> Option<&str> {
		TransferPartyOwnershipError::code(self)
	}
	fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
		match &self.kind {
			TransferPartyOwnershipErrorKind::InternalError(inner) => {
				Some(inner.retryable_error_kind())
			}
			TransferPartyOwnershipErrorKind::UnauthorizedError(inner) => {
				Some(inner.retryable_error_kind())
			}
			_ => None,
		}
	}
}
impl TransferPartyOwnershipError {
	/// Creates a new `TransferPartyOwnershipError`.
	pub fn new(kind: TransferPartyOwnershipErrorKind, meta: aws_smithy_types::Error) -> Self {
		Self { kind, meta }
	}

	/// Creates the `TransferPartyOwnershipError::Unhandled` variant from any error type.
	pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
		Self {
			kind: TransferPartyOwnershipErrorKind::Unhandled(err.into()),
			meta: Default::default(),
		}
	}

	/// Creates the `TransferPartyOwnershipError::Unhandled` variant from a `aws_smithy_types::Error`.
	pub fn generic(err: aws_smithy_types::Error) -> Self {
		Self {
			meta: err.clone(),
			kind: TransferPartyOwnershipErrorKind::Unhandled(err.into()),
		}
	}

	/// Returns the error message if one is available.
	pub fn message(&self) -> Option<&str> {
		self.meta.message()
	}

	/// Returns error metadata, which includes the error code, message,
	/// request ID, and potentially additional information.
	pub fn meta(&self) -> &aws_smithy_types::Error {
		&self.meta
	}

	/// Returns the request ID if it's available.
	pub fn request_id(&self) -> Option<&str> {
		self.meta.request_id()
	}

	/// Returns the error code if it's available.
	pub fn code(&self) -> Option<&str> {
		self.meta.code()
	}
	/// Returns `true` if the error kind is `TransferPartyOwnershipErrorKind::InternalError`.
	pub fn is_internal_error(&self) -> bool {
		matches!(
			&self.kind,
			TransferPartyOwnershipErrorKind::InternalError(_)
		)
	}
	/// Returns `true` if the error kind is `TransferPartyOwnershipErrorKind::RateLimitError`.
	pub fn is_rate_limit_error(&self) -> bool {
		matches!(
			&self.kind,
			TransferPartyOwnershipErrorKind::RateLimitError(_)
		)
	}
	/// Returns `true` if the error kind is `TransferPartyOwnershipErrorKind::ForbiddenError`.
	pub fn is_forbidden_error(&self) -> bool {
		matches!(
			&self.kind,
			TransferPartyOwnershipErrorKind::ForbiddenError(_)
		)
	}
	/// Returns `true` if the error kind is `TransferPartyOwnershipErrorKind::UnauthorizedError`.
	pub fn is_unauthorized_error(&self) -> bool {
		matches!(
			&self.kind,
			TransferPartyOwnershipErrorKind::UnauthorizedError(_)
		)
	}
	/// Returns `true` if the error kind is `TransferPartyOwnershipErrorKind::NotFoundError`.
	pub fn is_not_found_error(&self) -> bool {
		matches!(
			&self.kind,
			TransferPartyOwnershipErrorKind::NotFoundError(_)
		)
	}
	/// Returns `true` if the error kind is `TransferPartyOwnershipErrorKind::BadRequestError`.
	pub fn is_bad_request_error(&self) -> bool {
		matches!(
			&self.kind,
			TransferPartyOwnershipErrorKind::BadRequestError(_)
		)
	}
}
impl std::error::Error for TransferPartyOwnershipError {
	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
		match &self.kind {
			TransferPartyOwnershipErrorKind::InternalError(_inner) => Some(_inner),
			TransferPartyOwnershipErrorKind::RateLimitError(_inner) => Some(_inner),
			TransferPartyOwnershipErrorKind::ForbiddenError(_inner) => Some(_inner),
			TransferPartyOwnershipErrorKind::UnauthorizedError(_inner) => Some(_inner),
			TransferPartyOwnershipErrorKind::NotFoundError(_inner) => Some(_inner),
			TransferPartyOwnershipErrorKind::BadRequestError(_inner) => Some(_inner),
			TransferPartyOwnershipErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
		}
	}
}

/// Error type for the `FindMatchmakerLobbyForParty` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct FindMatchmakerLobbyForPartyError {
	/// Kind of error that occurred.
	pub kind: FindMatchmakerLobbyForPartyErrorKind,
	/// Additional metadata about the error, including error code, message, and request ID.
	pub(crate) meta: aws_smithy_types::Error,
}
/// Types of errors that can occur for the `FindMatchmakerLobbyForParty` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum FindMatchmakerLobbyForPartyErrorKind {
	/// An error caused by internal server problems.
	InternalError(crate::error::InternalError),
	/// An error thrown when the requestee has hit a rate limit. You are sending too many requests too quickly.
	RateLimitError(crate::error::RateLimitError),
	/// An error thrown when the requestee requests a resource they do not have access to.
	ForbiddenError(crate::error::ForbiddenError),
	/// An error thrown when the requestee is not authenticated.
	UnauthorizedError(crate::error::UnauthorizedError),
	/// An error thrown when the requestee requests a non existant resource.
	NotFoundError(crate::error::NotFoundError),
	/// An error thrown when the requestee has sent an invalid or malformed request.
	BadRequestError(crate::error::BadRequestError),
	/// An unexpected error, e.g. invalid JSON returned by the service or an unknown error code
	Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for FindMatchmakerLobbyForPartyError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		match &self.kind {
			FindMatchmakerLobbyForPartyErrorKind::InternalError(_inner) => _inner.fmt(f),
			FindMatchmakerLobbyForPartyErrorKind::RateLimitError(_inner) => _inner.fmt(f),
			FindMatchmakerLobbyForPartyErrorKind::ForbiddenError(_inner) => _inner.fmt(f),
			FindMatchmakerLobbyForPartyErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
			FindMatchmakerLobbyForPartyErrorKind::NotFoundError(_inner) => _inner.fmt(f),
			FindMatchmakerLobbyForPartyErrorKind::BadRequestError(_inner) => _inner.fmt(f),
			FindMatchmakerLobbyForPartyErrorKind::Unhandled(_inner) => _inner.fmt(f),
		}
	}
}
impl aws_smithy_types::retry::ProvideErrorKind for FindMatchmakerLobbyForPartyError {
	fn code(&self) -> Option<&str> {
		FindMatchmakerLobbyForPartyError::code(self)
	}
	fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
		match &self.kind {
			FindMatchmakerLobbyForPartyErrorKind::InternalError(inner) => {
				Some(inner.retryable_error_kind())
			}
			FindMatchmakerLobbyForPartyErrorKind::UnauthorizedError(inner) => {
				Some(inner.retryable_error_kind())
			}
			_ => None,
		}
	}
}
impl FindMatchmakerLobbyForPartyError {
	/// Creates a new `FindMatchmakerLobbyForPartyError`.
	pub fn new(kind: FindMatchmakerLobbyForPartyErrorKind, meta: aws_smithy_types::Error) -> Self {
		Self { kind, meta }
	}

	/// Creates the `FindMatchmakerLobbyForPartyError::Unhandled` variant from any error type.
	pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
		Self {
			kind: FindMatchmakerLobbyForPartyErrorKind::Unhandled(err.into()),
			meta: Default::default(),
		}
	}

	/// Creates the `FindMatchmakerLobbyForPartyError::Unhandled` variant from a `aws_smithy_types::Error`.
	pub fn generic(err: aws_smithy_types::Error) -> Self {
		Self {
			meta: err.clone(),
			kind: FindMatchmakerLobbyForPartyErrorKind::Unhandled(err.into()),
		}
	}

	/// Returns the error message if one is available.
	pub fn message(&self) -> Option<&str> {
		self.meta.message()
	}

	/// Returns error metadata, which includes the error code, message,
	/// request ID, and potentially additional information.
	pub fn meta(&self) -> &aws_smithy_types::Error {
		&self.meta
	}

	/// Returns the request ID if it's available.
	pub fn request_id(&self) -> Option<&str> {
		self.meta.request_id()
	}

	/// Returns the error code if it's available.
	pub fn code(&self) -> Option<&str> {
		self.meta.code()
	}
	/// Returns `true` if the error kind is `FindMatchmakerLobbyForPartyErrorKind::InternalError`.
	pub fn is_internal_error(&self) -> bool {
		matches!(
			&self.kind,
			FindMatchmakerLobbyForPartyErrorKind::InternalError(_)
		)
	}
	/// Returns `true` if the error kind is `FindMatchmakerLobbyForPartyErrorKind::RateLimitError`.
	pub fn is_rate_limit_error(&self) -> bool {
		matches!(
			&self.kind,
			FindMatchmakerLobbyForPartyErrorKind::RateLimitError(_)
		)
	}
	/// Returns `true` if the error kind is `FindMatchmakerLobbyForPartyErrorKind::ForbiddenError`.
	pub fn is_forbidden_error(&self) -> bool {
		matches!(
			&self.kind,
			FindMatchmakerLobbyForPartyErrorKind::ForbiddenError(_)
		)
	}
	/// Returns `true` if the error kind is `FindMatchmakerLobbyForPartyErrorKind::UnauthorizedError`.
	pub fn is_unauthorized_error(&self) -> bool {
		matches!(
			&self.kind,
			FindMatchmakerLobbyForPartyErrorKind::UnauthorizedError(_)
		)
	}
	/// Returns `true` if the error kind is `FindMatchmakerLobbyForPartyErrorKind::NotFoundError`.
	pub fn is_not_found_error(&self) -> bool {
		matches!(
			&self.kind,
			FindMatchmakerLobbyForPartyErrorKind::NotFoundError(_)
		)
	}
	/// Returns `true` if the error kind is `FindMatchmakerLobbyForPartyErrorKind::BadRequestError`.
	pub fn is_bad_request_error(&self) -> bool {
		matches!(
			&self.kind,
			FindMatchmakerLobbyForPartyErrorKind::BadRequestError(_)
		)
	}
}
impl std::error::Error for FindMatchmakerLobbyForPartyError {
	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
		match &self.kind {
			FindMatchmakerLobbyForPartyErrorKind::InternalError(_inner) => Some(_inner),
			FindMatchmakerLobbyForPartyErrorKind::RateLimitError(_inner) => Some(_inner),
			FindMatchmakerLobbyForPartyErrorKind::ForbiddenError(_inner) => Some(_inner),
			FindMatchmakerLobbyForPartyErrorKind::UnauthorizedError(_inner) => Some(_inner),
			FindMatchmakerLobbyForPartyErrorKind::NotFoundError(_inner) => Some(_inner),
			FindMatchmakerLobbyForPartyErrorKind::BadRequestError(_inner) => Some(_inner),
			FindMatchmakerLobbyForPartyErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
		}
	}
}

/// Error type for the `JoinMatchmakerLobbyForParty` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct JoinMatchmakerLobbyForPartyError {
	/// Kind of error that occurred.
	pub kind: JoinMatchmakerLobbyForPartyErrorKind,
	/// Additional metadata about the error, including error code, message, and request ID.
	pub(crate) meta: aws_smithy_types::Error,
}
/// Types of errors that can occur for the `JoinMatchmakerLobbyForParty` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum JoinMatchmakerLobbyForPartyErrorKind {
	/// An error caused by internal server problems.
	InternalError(crate::error::InternalError),
	/// An error thrown when the requestee has hit a rate limit. You are sending too many requests too quickly.
	RateLimitError(crate::error::RateLimitError),
	/// An error thrown when the requestee requests a resource they do not have access to.
	ForbiddenError(crate::error::ForbiddenError),
	/// An error thrown when the requestee is not authenticated.
	UnauthorizedError(crate::error::UnauthorizedError),
	/// An error thrown when the requestee requests a non existant resource.
	NotFoundError(crate::error::NotFoundError),
	/// An error thrown when the requestee has sent an invalid or malformed request.
	BadRequestError(crate::error::BadRequestError),
	/// An unexpected error, e.g. invalid JSON returned by the service or an unknown error code
	Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for JoinMatchmakerLobbyForPartyError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		match &self.kind {
			JoinMatchmakerLobbyForPartyErrorKind::InternalError(_inner) => _inner.fmt(f),
			JoinMatchmakerLobbyForPartyErrorKind::RateLimitError(_inner) => _inner.fmt(f),
			JoinMatchmakerLobbyForPartyErrorKind::ForbiddenError(_inner) => _inner.fmt(f),
			JoinMatchmakerLobbyForPartyErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
			JoinMatchmakerLobbyForPartyErrorKind::NotFoundError(_inner) => _inner.fmt(f),
			JoinMatchmakerLobbyForPartyErrorKind::BadRequestError(_inner) => _inner.fmt(f),
			JoinMatchmakerLobbyForPartyErrorKind::Unhandled(_inner) => _inner.fmt(f),
		}
	}
}
impl aws_smithy_types::retry::ProvideErrorKind for JoinMatchmakerLobbyForPartyError {
	fn code(&self) -> Option<&str> {
		JoinMatchmakerLobbyForPartyError::code(self)
	}
	fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
		match &self.kind {
			JoinMatchmakerLobbyForPartyErrorKind::InternalError(inner) => {
				Some(inner.retryable_error_kind())
			}
			JoinMatchmakerLobbyForPartyErrorKind::UnauthorizedError(inner) => {
				Some(inner.retryable_error_kind())
			}
			_ => None,
		}
	}
}
impl JoinMatchmakerLobbyForPartyError {
	/// Creates a new `JoinMatchmakerLobbyForPartyError`.
	pub fn new(kind: JoinMatchmakerLobbyForPartyErrorKind, meta: aws_smithy_types::Error) -> Self {
		Self { kind, meta }
	}

	/// Creates the `JoinMatchmakerLobbyForPartyError::Unhandled` variant from any error type.
	pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
		Self {
			kind: JoinMatchmakerLobbyForPartyErrorKind::Unhandled(err.into()),
			meta: Default::default(),
		}
	}

	/// Creates the `JoinMatchmakerLobbyForPartyError::Unhandled` variant from a `aws_smithy_types::Error`.
	pub fn generic(err: aws_smithy_types::Error) -> Self {
		Self {
			meta: err.clone(),
			kind: JoinMatchmakerLobbyForPartyErrorKind::Unhandled(err.into()),
		}
	}

	/// Returns the error message if one is available.
	pub fn message(&self) -> Option<&str> {
		self.meta.message()
	}

	/// Returns error metadata, which includes the error code, message,
	/// request ID, and potentially additional information.
	pub fn meta(&self) -> &aws_smithy_types::Error {
		&self.meta
	}

	/// Returns the request ID if it's available.
	pub fn request_id(&self) -> Option<&str> {
		self.meta.request_id()
	}

	/// Returns the error code if it's available.
	pub fn code(&self) -> Option<&str> {
		self.meta.code()
	}
	/// Returns `true` if the error kind is `JoinMatchmakerLobbyForPartyErrorKind::InternalError`.
	pub fn is_internal_error(&self) -> bool {
		matches!(
			&self.kind,
			JoinMatchmakerLobbyForPartyErrorKind::InternalError(_)
		)
	}
	/// Returns `true` if the error kind is `JoinMatchmakerLobbyForPartyErrorKind::RateLimitError`.
	pub fn is_rate_limit_error(&self) -> bool {
		matches!(
			&self.kind,
			JoinMatchmakerLobbyForPartyErrorKind::RateLimitError(_)
		)
	}
	/// Returns `true` if the error kind is `JoinMatchmakerLobbyForPartyErrorKind::ForbiddenError`.
	pub fn is_forbidden_error(&self) -> bool {
		matches!(
			&self.kind,
			JoinMatchmakerLobbyForPartyErrorKind::ForbiddenError(_)
		)
	}
	/// Returns `true` if the error kind is `JoinMatchmakerLobbyForPartyErrorKind::UnauthorizedError`.
	pub fn is_unauthorized_error(&self) -> bool {
		matches!(
			&self.kind,
			JoinMatchmakerLobbyForPartyErrorKind::UnauthorizedError(_)
		)
	}
	/// Returns `true` if the error kind is `JoinMatchmakerLobbyForPartyErrorKind::NotFoundError`.
	pub fn is_not_found_error(&self) -> bool {
		matches!(
			&self.kind,
			JoinMatchmakerLobbyForPartyErrorKind::NotFoundError(_)
		)
	}
	/// Returns `true` if the error kind is `JoinMatchmakerLobbyForPartyErrorKind::BadRequestError`.
	pub fn is_bad_request_error(&self) -> bool {
		matches!(
			&self.kind,
			JoinMatchmakerLobbyForPartyErrorKind::BadRequestError(_)
		)
	}
}
impl std::error::Error for JoinMatchmakerLobbyForPartyError {
	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
		match &self.kind {
			JoinMatchmakerLobbyForPartyErrorKind::InternalError(_inner) => Some(_inner),
			JoinMatchmakerLobbyForPartyErrorKind::RateLimitError(_inner) => Some(_inner),
			JoinMatchmakerLobbyForPartyErrorKind::ForbiddenError(_inner) => Some(_inner),
			JoinMatchmakerLobbyForPartyErrorKind::UnauthorizedError(_inner) => Some(_inner),
			JoinMatchmakerLobbyForPartyErrorKind::NotFoundError(_inner) => Some(_inner),
			JoinMatchmakerLobbyForPartyErrorKind::BadRequestError(_inner) => Some(_inner),
			JoinMatchmakerLobbyForPartyErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
		}
	}
}

/// Error type for the `RequestMatchmakerPlayer` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct RequestMatchmakerPlayerError {
	/// Kind of error that occurred.
	pub kind: RequestMatchmakerPlayerErrorKind,
	/// Additional metadata about the error, including error code, message, and request ID.
	pub(crate) meta: aws_smithy_types::Error,
}
/// Types of errors that can occur for the `RequestMatchmakerPlayer` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum RequestMatchmakerPlayerErrorKind {
	/// An error caused by internal server problems.
	InternalError(crate::error::InternalError),
	/// An error thrown when the requestee has hit a rate limit. You are sending too many requests too quickly.
	RateLimitError(crate::error::RateLimitError),
	/// An error thrown when the requestee requests a resource they do not have access to.
	ForbiddenError(crate::error::ForbiddenError),
	/// An error thrown when the requestee is not authenticated.
	UnauthorizedError(crate::error::UnauthorizedError),
	/// An error thrown when the requestee requests a non existant resource.
	NotFoundError(crate::error::NotFoundError),
	/// An error thrown when the requestee has sent an invalid or malformed request.
	BadRequestError(crate::error::BadRequestError),
	/// An unexpected error, e.g. invalid JSON returned by the service or an unknown error code
	Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for RequestMatchmakerPlayerError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		match &self.kind {
			RequestMatchmakerPlayerErrorKind::InternalError(_inner) => _inner.fmt(f),
			RequestMatchmakerPlayerErrorKind::RateLimitError(_inner) => _inner.fmt(f),
			RequestMatchmakerPlayerErrorKind::ForbiddenError(_inner) => _inner.fmt(f),
			RequestMatchmakerPlayerErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
			RequestMatchmakerPlayerErrorKind::NotFoundError(_inner) => _inner.fmt(f),
			RequestMatchmakerPlayerErrorKind::BadRequestError(_inner) => _inner.fmt(f),
			RequestMatchmakerPlayerErrorKind::Unhandled(_inner) => _inner.fmt(f),
		}
	}
}
impl aws_smithy_types::retry::ProvideErrorKind for RequestMatchmakerPlayerError {
	fn code(&self) -> Option<&str> {
		RequestMatchmakerPlayerError::code(self)
	}
	fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
		match &self.kind {
			RequestMatchmakerPlayerErrorKind::InternalError(inner) => {
				Some(inner.retryable_error_kind())
			}
			RequestMatchmakerPlayerErrorKind::UnauthorizedError(inner) => {
				Some(inner.retryable_error_kind())
			}
			_ => None,
		}
	}
}
impl RequestMatchmakerPlayerError {
	/// Creates a new `RequestMatchmakerPlayerError`.
	pub fn new(kind: RequestMatchmakerPlayerErrorKind, meta: aws_smithy_types::Error) -> Self {
		Self { kind, meta }
	}

	/// Creates the `RequestMatchmakerPlayerError::Unhandled` variant from any error type.
	pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
		Self {
			kind: RequestMatchmakerPlayerErrorKind::Unhandled(err.into()),
			meta: Default::default(),
		}
	}

	/// Creates the `RequestMatchmakerPlayerError::Unhandled` variant from a `aws_smithy_types::Error`.
	pub fn generic(err: aws_smithy_types::Error) -> Self {
		Self {
			meta: err.clone(),
			kind: RequestMatchmakerPlayerErrorKind::Unhandled(err.into()),
		}
	}

	/// Returns the error message if one is available.
	pub fn message(&self) -> Option<&str> {
		self.meta.message()
	}

	/// Returns error metadata, which includes the error code, message,
	/// request ID, and potentially additional information.
	pub fn meta(&self) -> &aws_smithy_types::Error {
		&self.meta
	}

	/// Returns the request ID if it's available.
	pub fn request_id(&self) -> Option<&str> {
		self.meta.request_id()
	}

	/// Returns the error code if it's available.
	pub fn code(&self) -> Option<&str> {
		self.meta.code()
	}
	/// Returns `true` if the error kind is `RequestMatchmakerPlayerErrorKind::InternalError`.
	pub fn is_internal_error(&self) -> bool {
		matches!(
			&self.kind,
			RequestMatchmakerPlayerErrorKind::InternalError(_)
		)
	}
	/// Returns `true` if the error kind is `RequestMatchmakerPlayerErrorKind::RateLimitError`.
	pub fn is_rate_limit_error(&self) -> bool {
		matches!(
			&self.kind,
			RequestMatchmakerPlayerErrorKind::RateLimitError(_)
		)
	}
	/// Returns `true` if the error kind is `RequestMatchmakerPlayerErrorKind::ForbiddenError`.
	pub fn is_forbidden_error(&self) -> bool {
		matches!(
			&self.kind,
			RequestMatchmakerPlayerErrorKind::ForbiddenError(_)
		)
	}
	/// Returns `true` if the error kind is `RequestMatchmakerPlayerErrorKind::UnauthorizedError`.
	pub fn is_unauthorized_error(&self) -> bool {
		matches!(
			&self.kind,
			RequestMatchmakerPlayerErrorKind::UnauthorizedError(_)
		)
	}
	/// Returns `true` if the error kind is `RequestMatchmakerPlayerErrorKind::NotFoundError`.
	pub fn is_not_found_error(&self) -> bool {
		matches!(
			&self.kind,
			RequestMatchmakerPlayerErrorKind::NotFoundError(_)
		)
	}
	/// Returns `true` if the error kind is `RequestMatchmakerPlayerErrorKind::BadRequestError`.
	pub fn is_bad_request_error(&self) -> bool {
		matches!(
			&self.kind,
			RequestMatchmakerPlayerErrorKind::BadRequestError(_)
		)
	}
}
impl std::error::Error for RequestMatchmakerPlayerError {
	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
		match &self.kind {
			RequestMatchmakerPlayerErrorKind::InternalError(_inner) => Some(_inner),
			RequestMatchmakerPlayerErrorKind::RateLimitError(_inner) => Some(_inner),
			RequestMatchmakerPlayerErrorKind::ForbiddenError(_inner) => Some(_inner),
			RequestMatchmakerPlayerErrorKind::UnauthorizedError(_inner) => Some(_inner),
			RequestMatchmakerPlayerErrorKind::NotFoundError(_inner) => Some(_inner),
			RequestMatchmakerPlayerErrorKind::BadRequestError(_inner) => Some(_inner),
			RequestMatchmakerPlayerErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
		}
	}
}

/// Error type for the `SetPartyToIdle` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct SetPartyToIdleError {
	/// Kind of error that occurred.
	pub kind: SetPartyToIdleErrorKind,
	/// Additional metadata about the error, including error code, message, and request ID.
	pub(crate) meta: aws_smithy_types::Error,
}
/// Types of errors that can occur for the `SetPartyToIdle` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum SetPartyToIdleErrorKind {
	/// An error caused by internal server problems.
	InternalError(crate::error::InternalError),
	/// An error thrown when the requestee has hit a rate limit. You are sending too many requests too quickly.
	RateLimitError(crate::error::RateLimitError),
	/// An error thrown when the requestee requests a resource they do not have access to.
	ForbiddenError(crate::error::ForbiddenError),
	/// An error thrown when the requestee is not authenticated.
	UnauthorizedError(crate::error::UnauthorizedError),
	/// An error thrown when the requestee requests a non existant resource.
	NotFoundError(crate::error::NotFoundError),
	/// An error thrown when the requestee has sent an invalid or malformed request.
	BadRequestError(crate::error::BadRequestError),
	/// An unexpected error, e.g. invalid JSON returned by the service or an unknown error code
	Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for SetPartyToIdleError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		match &self.kind {
			SetPartyToIdleErrorKind::InternalError(_inner) => _inner.fmt(f),
			SetPartyToIdleErrorKind::RateLimitError(_inner) => _inner.fmt(f),
			SetPartyToIdleErrorKind::ForbiddenError(_inner) => _inner.fmt(f),
			SetPartyToIdleErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
			SetPartyToIdleErrorKind::NotFoundError(_inner) => _inner.fmt(f),
			SetPartyToIdleErrorKind::BadRequestError(_inner) => _inner.fmt(f),
			SetPartyToIdleErrorKind::Unhandled(_inner) => _inner.fmt(f),
		}
	}
}
impl aws_smithy_types::retry::ProvideErrorKind for SetPartyToIdleError {
	fn code(&self) -> Option<&str> {
		SetPartyToIdleError::code(self)
	}
	fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
		match &self.kind {
			SetPartyToIdleErrorKind::InternalError(inner) => Some(inner.retryable_error_kind()),
			SetPartyToIdleErrorKind::UnauthorizedError(inner) => Some(inner.retryable_error_kind()),
			_ => None,
		}
	}
}
impl SetPartyToIdleError {
	/// Creates a new `SetPartyToIdleError`.
	pub fn new(kind: SetPartyToIdleErrorKind, meta: aws_smithy_types::Error) -> Self {
		Self { kind, meta }
	}

	/// Creates the `SetPartyToIdleError::Unhandled` variant from any error type.
	pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
		Self {
			kind: SetPartyToIdleErrorKind::Unhandled(err.into()),
			meta: Default::default(),
		}
	}

	/// Creates the `SetPartyToIdleError::Unhandled` variant from a `aws_smithy_types::Error`.
	pub fn generic(err: aws_smithy_types::Error) -> Self {
		Self {
			meta: err.clone(),
			kind: SetPartyToIdleErrorKind::Unhandled(err.into()),
		}
	}

	/// Returns the error message if one is available.
	pub fn message(&self) -> Option<&str> {
		self.meta.message()
	}

	/// Returns error metadata, which includes the error code, message,
	/// request ID, and potentially additional information.
	pub fn meta(&self) -> &aws_smithy_types::Error {
		&self.meta
	}

	/// Returns the request ID if it's available.
	pub fn request_id(&self) -> Option<&str> {
		self.meta.request_id()
	}

	/// Returns the error code if it's available.
	pub fn code(&self) -> Option<&str> {
		self.meta.code()
	}
	/// Returns `true` if the error kind is `SetPartyToIdleErrorKind::InternalError`.
	pub fn is_internal_error(&self) -> bool {
		matches!(&self.kind, SetPartyToIdleErrorKind::InternalError(_))
	}
	/// Returns `true` if the error kind is `SetPartyToIdleErrorKind::RateLimitError`.
	pub fn is_rate_limit_error(&self) -> bool {
		matches!(&self.kind, SetPartyToIdleErrorKind::RateLimitError(_))
	}
	/// Returns `true` if the error kind is `SetPartyToIdleErrorKind::ForbiddenError`.
	pub fn is_forbidden_error(&self) -> bool {
		matches!(&self.kind, SetPartyToIdleErrorKind::ForbiddenError(_))
	}
	/// Returns `true` if the error kind is `SetPartyToIdleErrorKind::UnauthorizedError`.
	pub fn is_unauthorized_error(&self) -> bool {
		matches!(&self.kind, SetPartyToIdleErrorKind::UnauthorizedError(_))
	}
	/// Returns `true` if the error kind is `SetPartyToIdleErrorKind::NotFoundError`.
	pub fn is_not_found_error(&self) -> bool {
		matches!(&self.kind, SetPartyToIdleErrorKind::NotFoundError(_))
	}
	/// Returns `true` if the error kind is `SetPartyToIdleErrorKind::BadRequestError`.
	pub fn is_bad_request_error(&self) -> bool {
		matches!(&self.kind, SetPartyToIdleErrorKind::BadRequestError(_))
	}
}
impl std::error::Error for SetPartyToIdleError {
	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
		match &self.kind {
			SetPartyToIdleErrorKind::InternalError(_inner) => Some(_inner),
			SetPartyToIdleErrorKind::RateLimitError(_inner) => Some(_inner),
			SetPartyToIdleErrorKind::ForbiddenError(_inner) => Some(_inner),
			SetPartyToIdleErrorKind::UnauthorizedError(_inner) => Some(_inner),
			SetPartyToIdleErrorKind::NotFoundError(_inner) => Some(_inner),
			SetPartyToIdleErrorKind::BadRequestError(_inner) => Some(_inner),
			SetPartyToIdleErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
		}
	}
}

/// An error thrown when the requestee has sent an invalid or malformed request.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct BadRequestError {
	#[allow(missing_docs)] // documentation missing in model
	pub code: std::option::Option<std::string::String>,
	#[allow(missing_docs)] // documentation missing in model
	pub message: std::option::Option<std::string::String>,
	/// Unstructured metadata relating to an error. Must be manually parsed.
	pub metadata: std::option::Option<aws_smithy_types::Document>,
}
impl BadRequestError {
	#[allow(missing_docs)] // documentation missing in model
	pub fn code(&self) -> std::option::Option<&str> {
		self.code.as_deref()
	}
	/// Unstructured metadata relating to an error. Must be manually parsed.
	pub fn metadata(&self) -> std::option::Option<&aws_smithy_types::Document> {
		self.metadata.as_ref()
	}
}
impl std::fmt::Debug for BadRequestError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("BadRequestError");
		formatter.field("code", &self.code);
		formatter.field("message", &self.message);
		formatter.field("metadata", &self.metadata);
		formatter.finish()
	}
}
impl BadRequestError {
	/// Returns the error message.
	pub fn message(&self) -> Option<&str> {
		self.message.as_deref()
	}
}
impl std::fmt::Display for BadRequestError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		write!(f, "BadRequestError")?;
		if let Some(inner_1) = &self.message {
			write!(f, ": {}", inner_1)?;
		}
		Ok(())
	}
}
impl std::error::Error for BadRequestError {}
/// See [`BadRequestError`](crate::error::BadRequestError)
pub mod bad_request_error {
	/// A builder for [`BadRequestError`](crate::error::BadRequestError)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) code: std::option::Option<std::string::String>,
		pub(crate) message: std::option::Option<std::string::String>,
		pub(crate) metadata: std::option::Option<aws_smithy_types::Document>,
	}
	impl Builder {
		#[allow(missing_docs)] // documentation missing in model
		pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
			self.code = Some(input.into());
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.code = input;
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
			self.message = Some(input.into());
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.message = input;
			self
		}
		/// Unstructured metadata relating to an error. Must be manually parsed.
		pub fn metadata(mut self, input: aws_smithy_types::Document) -> Self {
			self.metadata = Some(input);
			self
		}
		/// Unstructured metadata relating to an error. Must be manually parsed.
		pub fn set_metadata(
			mut self,
			input: std::option::Option<aws_smithy_types::Document>,
		) -> Self {
			self.metadata = input;
			self
		}
		/// Consumes the builder and constructs a [`BadRequestError`](crate::error::BadRequestError)
		pub fn build(self) -> crate::error::BadRequestError {
			crate::error::BadRequestError {
				code: self.code,
				message: self.message,
				metadata: self.metadata,
			}
		}
	}
}
impl BadRequestError {
	/// Creates a new builder-style object to manufacture [`BadRequestError`](crate::error::BadRequestError)
	pub fn builder() -> crate::error::bad_request_error::Builder {
		crate::error::bad_request_error::Builder::default()
	}
}

/// An error thrown when the requestee requests a non existant resource.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct NotFoundError {
	#[allow(missing_docs)] // documentation missing in model
	pub code: std::option::Option<std::string::String>,
	#[allow(missing_docs)] // documentation missing in model
	pub message: std::option::Option<std::string::String>,
	/// Unstructured metadata relating to an error. Must be manually parsed.
	pub metadata: std::option::Option<aws_smithy_types::Document>,
}
impl NotFoundError {
	#[allow(missing_docs)] // documentation missing in model
	pub fn code(&self) -> std::option::Option<&str> {
		self.code.as_deref()
	}
	/// Unstructured metadata relating to an error. Must be manually parsed.
	pub fn metadata(&self) -> std::option::Option<&aws_smithy_types::Document> {
		self.metadata.as_ref()
	}
}
impl std::fmt::Debug for NotFoundError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("NotFoundError");
		formatter.field("code", &self.code);
		formatter.field("message", &self.message);
		formatter.field("metadata", &self.metadata);
		formatter.finish()
	}
}
impl NotFoundError {
	/// Returns the error message.
	pub fn message(&self) -> Option<&str> {
		self.message.as_deref()
	}
}
impl std::fmt::Display for NotFoundError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		write!(f, "NotFoundError")?;
		if let Some(inner_2) = &self.message {
			write!(f, ": {}", inner_2)?;
		}
		Ok(())
	}
}
impl std::error::Error for NotFoundError {}
/// See [`NotFoundError`](crate::error::NotFoundError)
pub mod not_found_error {
	/// A builder for [`NotFoundError`](crate::error::NotFoundError)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) code: std::option::Option<std::string::String>,
		pub(crate) message: std::option::Option<std::string::String>,
		pub(crate) metadata: std::option::Option<aws_smithy_types::Document>,
	}
	impl Builder {
		#[allow(missing_docs)] // documentation missing in model
		pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
			self.code = Some(input.into());
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.code = input;
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
			self.message = Some(input.into());
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.message = input;
			self
		}
		/// Unstructured metadata relating to an error. Must be manually parsed.
		pub fn metadata(mut self, input: aws_smithy_types::Document) -> Self {
			self.metadata = Some(input);
			self
		}
		/// Unstructured metadata relating to an error. Must be manually parsed.
		pub fn set_metadata(
			mut self,
			input: std::option::Option<aws_smithy_types::Document>,
		) -> Self {
			self.metadata = input;
			self
		}
		/// Consumes the builder and constructs a [`NotFoundError`](crate::error::NotFoundError)
		pub fn build(self) -> crate::error::NotFoundError {
			crate::error::NotFoundError {
				code: self.code,
				message: self.message,
				metadata: self.metadata,
			}
		}
	}
}
impl NotFoundError {
	/// Creates a new builder-style object to manufacture [`NotFoundError`](crate::error::NotFoundError)
	pub fn builder() -> crate::error::not_found_error::Builder {
		crate::error::not_found_error::Builder::default()
	}
}

/// An error thrown when the requestee is not authenticated.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UnauthorizedError {
	#[allow(missing_docs)] // documentation missing in model
	pub code: std::option::Option<std::string::String>,
	#[allow(missing_docs)] // documentation missing in model
	pub message: std::option::Option<std::string::String>,
	/// Unstructured metadata relating to an error. Must be manually parsed.
	pub metadata: std::option::Option<aws_smithy_types::Document>,
}
impl UnauthorizedError {
	#[allow(missing_docs)] // documentation missing in model
	pub fn code(&self) -> std::option::Option<&str> {
		self.code.as_deref()
	}
	/// Unstructured metadata relating to an error. Must be manually parsed.
	pub fn metadata(&self) -> std::option::Option<&aws_smithy_types::Document> {
		self.metadata.as_ref()
	}
}
impl std::fmt::Debug for UnauthorizedError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("UnauthorizedError");
		formatter.field("code", &self.code);
		formatter.field("message", &self.message);
		formatter.field("metadata", &self.metadata);
		formatter.finish()
	}
}
impl UnauthorizedError {
	/// Returns `Some(ErrorKind)` if the error is retryable. Otherwise, returns `None`.
	pub fn retryable_error_kind(&self) -> aws_smithy_types::retry::ErrorKind {
		aws_smithy_types::retry::ErrorKind::ClientError
	}
	/// Returns the error message.
	pub fn message(&self) -> Option<&str> {
		self.message.as_deref()
	}
}
impl std::fmt::Display for UnauthorizedError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		write!(f, "UnauthorizedError")?;
		if let Some(inner_3) = &self.message {
			write!(f, ": {}", inner_3)?;
		}
		Ok(())
	}
}
impl std::error::Error for UnauthorizedError {}
/// See [`UnauthorizedError`](crate::error::UnauthorizedError)
pub mod unauthorized_error {
	/// A builder for [`UnauthorizedError`](crate::error::UnauthorizedError)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) code: std::option::Option<std::string::String>,
		pub(crate) message: std::option::Option<std::string::String>,
		pub(crate) metadata: std::option::Option<aws_smithy_types::Document>,
	}
	impl Builder {
		#[allow(missing_docs)] // documentation missing in model
		pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
			self.code = Some(input.into());
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.code = input;
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
			self.message = Some(input.into());
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.message = input;
			self
		}
		/// Unstructured metadata relating to an error. Must be manually parsed.
		pub fn metadata(mut self, input: aws_smithy_types::Document) -> Self {
			self.metadata = Some(input);
			self
		}
		/// Unstructured metadata relating to an error. Must be manually parsed.
		pub fn set_metadata(
			mut self,
			input: std::option::Option<aws_smithy_types::Document>,
		) -> Self {
			self.metadata = input;
			self
		}
		/// Consumes the builder and constructs a [`UnauthorizedError`](crate::error::UnauthorizedError)
		pub fn build(self) -> crate::error::UnauthorizedError {
			crate::error::UnauthorizedError {
				code: self.code,
				message: self.message,
				metadata: self.metadata,
			}
		}
	}
}
impl UnauthorizedError {
	/// Creates a new builder-style object to manufacture [`UnauthorizedError`](crate::error::UnauthorizedError)
	pub fn builder() -> crate::error::unauthorized_error::Builder {
		crate::error::unauthorized_error::Builder::default()
	}
}

/// An error thrown when the requestee requests a resource they do not have access to.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ForbiddenError {
	#[allow(missing_docs)] // documentation missing in model
	pub code: std::option::Option<std::string::String>,
	#[allow(missing_docs)] // documentation missing in model
	pub message: std::option::Option<std::string::String>,
	/// Unstructured metadata relating to an error. Must be manually parsed.
	pub metadata: std::option::Option<aws_smithy_types::Document>,
}
impl ForbiddenError {
	#[allow(missing_docs)] // documentation missing in model
	pub fn code(&self) -> std::option::Option<&str> {
		self.code.as_deref()
	}
	/// Unstructured metadata relating to an error. Must be manually parsed.
	pub fn metadata(&self) -> std::option::Option<&aws_smithy_types::Document> {
		self.metadata.as_ref()
	}
}
impl std::fmt::Debug for ForbiddenError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("ForbiddenError");
		formatter.field("code", &self.code);
		formatter.field("message", &self.message);
		formatter.field("metadata", &self.metadata);
		formatter.finish()
	}
}
impl ForbiddenError {
	/// Returns the error message.
	pub fn message(&self) -> Option<&str> {
		self.message.as_deref()
	}
}
impl std::fmt::Display for ForbiddenError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		write!(f, "ForbiddenError")?;
		if let Some(inner_4) = &self.message {
			write!(f, ": {}", inner_4)?;
		}
		Ok(())
	}
}
impl std::error::Error for ForbiddenError {}
/// See [`ForbiddenError`](crate::error::ForbiddenError)
pub mod forbidden_error {
	/// A builder for [`ForbiddenError`](crate::error::ForbiddenError)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) code: std::option::Option<std::string::String>,
		pub(crate) message: std::option::Option<std::string::String>,
		pub(crate) metadata: std::option::Option<aws_smithy_types::Document>,
	}
	impl Builder {
		#[allow(missing_docs)] // documentation missing in model
		pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
			self.code = Some(input.into());
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.code = input;
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
			self.message = Some(input.into());
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.message = input;
			self
		}
		/// Unstructured metadata relating to an error. Must be manually parsed.
		pub fn metadata(mut self, input: aws_smithy_types::Document) -> Self {
			self.metadata = Some(input);
			self
		}
		/// Unstructured metadata relating to an error. Must be manually parsed.
		pub fn set_metadata(
			mut self,
			input: std::option::Option<aws_smithy_types::Document>,
		) -> Self {
			self.metadata = input;
			self
		}
		/// Consumes the builder and constructs a [`ForbiddenError`](crate::error::ForbiddenError)
		pub fn build(self) -> crate::error::ForbiddenError {
			crate::error::ForbiddenError {
				code: self.code,
				message: self.message,
				metadata: self.metadata,
			}
		}
	}
}
impl ForbiddenError {
	/// Creates a new builder-style object to manufacture [`ForbiddenError`](crate::error::ForbiddenError)
	pub fn builder() -> crate::error::forbidden_error::Builder {
		crate::error::forbidden_error::Builder::default()
	}
}

/// An error thrown when the requestee has hit a rate limit. You are sending too many requests too quickly.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct RateLimitError {
	#[allow(missing_docs)] // documentation missing in model
	pub code: std::option::Option<std::string::String>,
	#[allow(missing_docs)] // documentation missing in model
	pub message: std::option::Option<std::string::String>,
	/// Unstructured metadata relating to an error. Must be manually parsed.
	pub metadata: std::option::Option<aws_smithy_types::Document>,
}
impl RateLimitError {
	#[allow(missing_docs)] // documentation missing in model
	pub fn code(&self) -> std::option::Option<&str> {
		self.code.as_deref()
	}
	/// Unstructured metadata relating to an error. Must be manually parsed.
	pub fn metadata(&self) -> std::option::Option<&aws_smithy_types::Document> {
		self.metadata.as_ref()
	}
}
impl std::fmt::Debug for RateLimitError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("RateLimitError");
		formatter.field("code", &self.code);
		formatter.field("message", &self.message);
		formatter.field("metadata", &self.metadata);
		formatter.finish()
	}
}
impl RateLimitError {
	/// Returns the error message.
	pub fn message(&self) -> Option<&str> {
		self.message.as_deref()
	}
}
impl std::fmt::Display for RateLimitError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		write!(f, "RateLimitError")?;
		if let Some(inner_5) = &self.message {
			write!(f, ": {}", inner_5)?;
		}
		Ok(())
	}
}
impl std::error::Error for RateLimitError {}
/// See [`RateLimitError`](crate::error::RateLimitError)
pub mod rate_limit_error {
	/// A builder for [`RateLimitError`](crate::error::RateLimitError)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) code: std::option::Option<std::string::String>,
		pub(crate) message: std::option::Option<std::string::String>,
		pub(crate) metadata: std::option::Option<aws_smithy_types::Document>,
	}
	impl Builder {
		#[allow(missing_docs)] // documentation missing in model
		pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
			self.code = Some(input.into());
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.code = input;
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
			self.message = Some(input.into());
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.message = input;
			self
		}
		/// Unstructured metadata relating to an error. Must be manually parsed.
		pub fn metadata(mut self, input: aws_smithy_types::Document) -> Self {
			self.metadata = Some(input);
			self
		}
		/// Unstructured metadata relating to an error. Must be manually parsed.
		pub fn set_metadata(
			mut self,
			input: std::option::Option<aws_smithy_types::Document>,
		) -> Self {
			self.metadata = input;
			self
		}
		/// Consumes the builder and constructs a [`RateLimitError`](crate::error::RateLimitError)
		pub fn build(self) -> crate::error::RateLimitError {
			crate::error::RateLimitError {
				code: self.code,
				message: self.message,
				metadata: self.metadata,
			}
		}
	}
}
impl RateLimitError {
	/// Creates a new builder-style object to manufacture [`RateLimitError`](crate::error::RateLimitError)
	pub fn builder() -> crate::error::rate_limit_error::Builder {
		crate::error::rate_limit_error::Builder::default()
	}
}

/// An error caused by internal server problems.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct InternalError {
	#[allow(missing_docs)] // documentation missing in model
	pub code: std::option::Option<std::string::String>,
	#[allow(missing_docs)] // documentation missing in model
	pub message: std::option::Option<std::string::String>,
	/// Unstructured metadata relating to an error. Must be manually parsed.
	pub metadata: std::option::Option<aws_smithy_types::Document>,
}
impl InternalError {
	#[allow(missing_docs)] // documentation missing in model
	pub fn code(&self) -> std::option::Option<&str> {
		self.code.as_deref()
	}
	/// Unstructured metadata relating to an error. Must be manually parsed.
	pub fn metadata(&self) -> std::option::Option<&aws_smithy_types::Document> {
		self.metadata.as_ref()
	}
}
impl std::fmt::Debug for InternalError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		let mut formatter = f.debug_struct("InternalError");
		formatter.field("code", &self.code);
		formatter.field("message", &self.message);
		formatter.field("metadata", &self.metadata);
		formatter.finish()
	}
}
impl InternalError {
	/// Returns `Some(ErrorKind)` if the error is retryable. Otherwise, returns `None`.
	pub fn retryable_error_kind(&self) -> aws_smithy_types::retry::ErrorKind {
		aws_smithy_types::retry::ErrorKind::ServerError
	}
	/// Returns the error message.
	pub fn message(&self) -> Option<&str> {
		self.message.as_deref()
	}
}
impl std::fmt::Display for InternalError {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		write!(f, "InternalError")?;
		if let Some(inner_6) = &self.message {
			write!(f, ": {}", inner_6)?;
		}
		Ok(())
	}
}
impl std::error::Error for InternalError {}
/// See [`InternalError`](crate::error::InternalError)
pub mod internal_error {
	/// A builder for [`InternalError`](crate::error::InternalError)
	#[non_exhaustive]
	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
	pub struct Builder {
		pub(crate) code: std::option::Option<std::string::String>,
		pub(crate) message: std::option::Option<std::string::String>,
		pub(crate) metadata: std::option::Option<aws_smithy_types::Document>,
	}
	impl Builder {
		#[allow(missing_docs)] // documentation missing in model
		pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
			self.code = Some(input.into());
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.code = input;
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
			self.message = Some(input.into());
			self
		}
		#[allow(missing_docs)] // documentation missing in model
		pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
			self.message = input;
			self
		}
		/// Unstructured metadata relating to an error. Must be manually parsed.
		pub fn metadata(mut self, input: aws_smithy_types::Document) -> Self {
			self.metadata = Some(input);
			self
		}
		/// Unstructured metadata relating to an error. Must be manually parsed.
		pub fn set_metadata(
			mut self,
			input: std::option::Option<aws_smithy_types::Document>,
		) -> Self {
			self.metadata = input;
			self
		}
		/// Consumes the builder and constructs a [`InternalError`](crate::error::InternalError)
		pub fn build(self) -> crate::error::InternalError {
			crate::error::InternalError {
				code: self.code,
				message: self.message,
				metadata: self.metadata,
			}
		}
	}
}
impl InternalError {
	/// Creates a new builder-style object to manufacture [`InternalError`](crate::error::InternalError)
	pub fn builder() -> crate::error::internal_error::Builder {
		crate::error::internal_error::Builder::default()
	}
}